Amiga Plus 2002 #11/Amiga Plus CD - 2002 - No. 11.iso/Games/WormWars/Source/engine.c

C/C++ Source or Header | 2002-10-16 | 189.2 KB | 5,332 lines

/* $Filename: WormWars/Source/engine.c
 * $VER:      WormWars 7.21
 *
 * © Copyright 1993-2002 James R. Jacobs. Freely distributable.
 */

#include <string.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h> /* EXIT_SUCCESS, EXIT_FAILURE */
#include <assert.h>
#define ASSERT

#include "stdafx.h"
#include "diff.h"
#include "same.h"

#define OTTER_UP    0
#define OTTER_DOWN  1
#define OTTER_LEFT  2
#define OTTER_RIGHT 3

#define ARROWX               (FIELDX + 1)
#define BONUSSPEEDUP         8 // 8 times more common on bonus levels
#define NOSE                 2 // if (NOSE > PROTECTORS) nose disabled
#define WORMQUEUELIMIT      15
#define DOGQUEUELIMIT      120
#define TIMELIMIT          599
#define SECONDSPERLEVEL    120 // assert (SECONDSPERLEVEL <= TIMELIMIT);
#define WEIGHT               5

// dog dormancy
#define DORMANT              0
#define AWAKENING            1
#define CHASING             10

// population limits
#define CREATURES           50
#define MAGNETS             20
#define PROTECTORS           2 // <=4!
#define OCTOPI              12 // this limit applies only to predefined octopi

#define FREQ_BIRD          140
#define FREQ_CLOUD          55
#define FREQ_CLOUDFIRE      30
#define FREQ_DOG            55
#define FREQ_DRIP           15
#define FREQ_FISH          105
#define FREQ_GIRAFFE        50
#define FREQ_GOAT           35
#define FREQ_GOATFIRE       10
#define FREQ_GOATMOVE        5
#define FREQ_LION           50
#define FREQ_LIONTURN       20
#define FREQ_OCTOPUS        95
#define FREQ_OCTOPUSFIRE    40
#define FREQ_OCTOPUSSPIN     3
#define FREQ_ORB            35
#define FREQ_PENGUIN        50
#define FREQ_SLIME          80
#define FREQ_SLIMEGROW      75
#define FREQ_TELEPORT      210
#define FREQ_TIMEBOMB      210

#define SPEED_BIRD          13
#define SPEED_CLOUD          9
#define SPEED_DOG            3
#define SPEED_DRIP           4
#define SPEED_FISH          12
#define SPEED_FRAGMENT       3
#define SPEED_GIRAFFE      255 // giraffe never needs to move
#define SPEED_GOAT          16
#define SPEED_LION           9
#define SPEED_MAGNET         9
#define SPEED_MISSILE        7
#define SPEED_OCTOPUS       16
#define SPEED_ORB            6
#define SPEED_OTTER         19
#define SPEED_PENGUIN       11
#define SPEED_TIMEBOMB      60
#define SPEED_WHIRLWIND      1

#define HARDNESS_BIRD       50
#define HARDNESS_CLOUD      50
#define HARDNESS_DOG        50
#define HARDNESS_DRIP       50
#define HARDNESS_FISH       50
#define HARDNESS_FRAGMENT   50
#define HARDNESS_GIRAFFE    50
#define HARDNESS_GOAT       50
#define HARDNESS_LION       60
#define HARDNESS_MISSILE    50
#define HARDNESS_OCTOPUS    50
#define HARDNESS_OTTER      95
#define HARDNESS_ORB        50
#define HARDNESS_PENGUIN    10
#define HARDNESS_TIMEBOMB   80
#define HARDNESS_WHIRLWIND  90

#define DISTANCE_FAST        5
#define DISTANCE_BIRD        3
#define DISTANCE_GIRAFFE     5
#define DISTANCE_NORMAL      4
#define DISTANCE_NOSE        4
#define DISTANCE_SLOW        3
#define DISTANCE_VERYSLOW    2

#define POINTS_EMPTY         1
#define POINTS_DYNAMITE      5
#define POINTS_TURNSILVER    5
#define POINTS_ENCLOSURE    10
#define POINTS_SILVER       10
#define POINTS_TURNGOLD     10
#define POINTS_GOLD         20
#define POINTS_LETTER      100
#define POINTS_GRAVE       100

#define  ADD_BOMB      5 // in squares radius
#define  ADD_CLOCK    10 // in seconds
#define  ADD_CUTTER   10 // in VERYSLOWs
#define  ADD_GLOW     30 // in VERYSLOWs
#define  ADD_ICE      10 // in VERYSLOWs
#define  ADD_ARMOUR   25 // in VERYSLOWs
#define  ADD_TREASURE 10 // in seconds
#define RAND_BOMB     25
#define RAND_CLOCK    20
#define RAND_CUTTER   20
#define RAND_GLOW     50
#define RAND_ICE       5
#define RAND_ARMOUR   25
#define RAND_TREASURE 10

MODULE  void changefield(void);
MODULE  void death(void);
MODULE  void fastloop(void);
MODULE  void killall(void);
MODULE  void magnetloop(void);
MODULE  void newhiscores(void);
MODULE  void slowloop(void);
MODULE  void ReadGameports(void);
MODULE  void endoflevel(void);

MODULE  void bangdynamite(SBYTE x, SBYTE y, SBYTE player);
MODULE  void bombblast(SBYTE triggerer, SBYTE player, SBYTE centrex, SBYTE centrey);
MODULE  void bothcol(SBYTE player, SBYTE x, SBYTE y);
MODULE  void bounceoffcreature(UBYTE which, SBYTE x, SBYTE y);
MODULE  void __inline change(SBYTE x, SBYTE y, UBYTE image);
MODULE  void checkrectangle(SBYTE direction, SBYTE player, SBYTE horizontalsize, SBYTE verticalsize);
MODULE  void cloudbullet(UBYTE which, SBYTE x, SBYTE y, SBYTE deltay);
MODULE  void creatureloop(SBYTE which);
MODULE  void dogqueue(SBYTE which, SBYTE deltax, SBYTE deltay);
MODULE  void drawcause(SBYTE player, SBYTE state);
MODULE  void newlevel(UBYTE player);
MODULE  void orbsplit(SBYTE which);
MODULE  void protcol(SBYTE player, SBYTE x, SBYTE y, SBYTE thisprot);
MODULE  void putnumber(void);
MODULE  void ramming(SBYTE player);
MODULE  void reflect(UBYTE which);
MODULE  void turnworm(SBYTE player, SBYTE deltax, SBYTE deltay);
MODULE  void updatearrow(SBYTE arrowy);
MODULE  void wormbullet(SBYTE player);
MODULE  void wormloop(SBYTE player);
MODULE  void wormcol(SBYTE player, SBYTE x, SBYTE y);

MODULE void wormworm(SBYTE x, SBYTE y, UBYTE which1, UBYTE which2);
MODULE void protworm(SBYTE x, SBYTE y, UBYTE which1, UBYTE which2);
MODULE void protprot(SBYTE x, SBYTE y, UBYTE which1, UBYTE which2);
MODULE void octopusfire(UBYTE which);
MODULE void squareblast(SBYTE type, SBYTE player, UBYTE c, SBYTE x, SBYTE y, ABOOL cutter);
MODULE void drawmissile(SBYTE x, SBYTE y, UBYTE which);

MODULE SWORD atleast(SWORD value, SWORD minimum);
MODULE ABOOL blocked(UBYTE which, SBYTE deltax, SBYTE deltay);
MODULE ABOOL bouncecreature(UBYTE which, SBYTE x, SBYTE y);
MODULE SBYTE bsign(SBYTE value);
MODULE ABOOL findempty(SBYTE* x, SBYTE* y, ABOOL mode);
MODULE FLAG  getnumber(SBYTE player);
MODULE SBYTE onlyworm(ABOOL alive);
MODULE SBYTE slowdown(SBYTE speed, ABOOL brakes);
MODULE SBYTE speedup(SBYTE speed, ABOOL brakes);
MODULE UBYTE whichcreature(SBYTE x, SBYTE y, UBYTE species, UBYTE exception);
MODULE SBYTE whichteleport(SBYTE x, SBYTE y);
MODULE ULONG wormobject(UBYTE player, SBYTE x, SBYTE y);

MODULE void wormkillcreature(UBYTE player, UBYTE which);
MODULE void createcreature(UBYTE species, UBYTE which, SBYTE x, SBYTE y, SBYTE deltax, SBYTE deltay, UBYTE player);
MODULE ULONG arand(ULONG number);
MODULE void protcreature(UBYTE player, UBYTE which);
MODULE void wormcreature(UBYTE player, UBYTE which);
MODULE void creaturecreature(UBYTE which1, UBYTE which2);

/* PRIVATE STRUCTURES -------------------------------------------------- */

struct
{   SBYTE x, y, deltax, deltay;
    ABOOL alive, moved, teleported, visible, reflected;
} bullet[9];
struct
{   UWORD freq;
    ULONG score;
} object[LASTOBJECT + 1] =
{   {1590,  60}, // AFFIXER
    {  65,  20}, // AMMO
    { 105,  20}, // ARMOUR
    {  90,  50}, // BIAS
    { 130,  30}, // BOMB
    { 115,  10}, // BONUS
    { 280,  10}, // BRAKES
    { 890,  60}, // CLOCK
    { 370,  50}, // CONVERTER
    { 300,  80}, // CUTTER
    { 255,  90}, // CYCLONE
    { 315,  20}, // ENCLOSER
    { 115,  30}, // GLOW
    { 205,  50}, // GROWER
    {1900,  90}, // HEALER
    { 950,  60}, // ICE
    { 140,  60}, // LIFE
    { 165,  80}, // LIGHTNING
    { 930,  80}, // MAGNET
    { 210,  40}, // MISSILE
    { 630,  50}, // MULTIPLIER
    { 235,  30}, // POWER
    { 465,  50}, // PROTECTOR
    { 210,  40}, // PULSE
    { 300,  50}, // PUSHER
    { 400,  40}, // REMNANTS
    { 500,  30}, // SIDESHOT
    { 480,  40}, // SLAYER
    { 975,  40}, // SLOWER
    { 710,  70}, // SWITCHER
    {1490, 120}, // TREASURE
    {3885, 140}  // UMBRELLA
};

/*  -200    common
    220-400 uncommon
    420-980 rare
    1000+   very rare */

struct
{   SBYTE x, y, deltax, deltay, relx, rely;
    ABOOL alive, last, visible;
} protector[4][PROTECTORS + 1];
struct
{   SBYTE deltax, deltay;
} thewormqueue[4][WORMQUEUELIMIT + 1];
struct
{   SBYTE deltax, deltay;
} thedogqueue[CREATURES + 1][DOGQUEUELIMIT + 1];
struct
{   ABOOL alive;
    SBYTE x, y, player;
    UBYTE object;
} magnet[MAGNETS + 1];

AGLOBAL UBYTE missileframes[4][MISSILEFRAMES + 1] =
{ { FIRSTMISSILE,
    FIRSTMISSILEFRAME,
    FIRSTMISSILEFRAME + 1,
    FIRSTMISSILEFRAME + 2,
    FIRSTMISSILEFRAME + 3,
    FIRSTMISSILEFRAME + 4
  },
  { FIRSTMISSILE + 1,
    FIRSTMISSILEFRAME + 5,
    FIRSTMISSILEFRAME + 6,
    FIRSTMISSILEFRAME + 7,
    FIRSTMISSILEFRAME + 8,
    FIRSTMISSILEFRAME + 9
  },
  { FIRSTMISSILE + 2,
    FIRSTMISSILEFRAME + 10,
    FIRSTMISSILEFRAME + 11,
    FIRSTMISSILEFRAME + 12,
    FIRSTMISSILEFRAME + 13,
    FIRSTMISSILEFRAME + 14,
  },
  { FIRSTMISSILE + 3,
    FIRSTMISSILEFRAME + 15,
    FIRSTMISSILEFRAME + 16,
    FIRSTMISSILEFRAME + 17,
    FIRSTMISSILEFRAME + 18,
    FIRSTMISSILEFRAME + 19
} };

UBYTE eachworm[4][2][9] =
{ { { GREENHEAD_NW,  GREENHEADUP,   GREENHEAD_NE,
      GREENHEADLEFT, ANYTHING,      GREENHEADRIGHT,
      GREENHEAD_SW,  GREENHEADDOWN, GREENHEAD_SE
    },
    { GREENGLOW_NW,  GREENGLOWUP,   GREENGLOW_NE,
      GREENGLOWLEFT, ANYTHING,      GREENGLOWRIGHT,
      GREENGLOW_SW,  GREENGLOWDOWN, GREENGLOW_SE
  } },
  { { REDHEAD_NW,    REDHEADUP,     REDHEAD_NE,
      REDHEADLEFT,   ANYTHING,      REDHEADRIGHT,
      REDHEAD_SW,    REDHEADDOWN,   REDHEAD_SE
    },
    { REDGLOW_NW,    REDGLOWUP,     REDGLOW_NE,
      REDGLOWLEFT,   ANYTHING,      REDGLOWRIGHT,
      REDGLOW_SW,    REDGLOWDOWN,   REDGLOW_SE
  } },
  { { BLUEHEAD_NW,   BLUEHEADUP,    BLUEHEAD_NE,
      BLUEHEADLEFT,  ANYTHING,      BLUEHEADRIGHT,
      BLUEHEAD_SW,   BLUEHEADDOWN,  BLUEHEAD_SE
    },
    { BLUEGLOW_NW,   BLUEGLOWUP,    BLUEGLOW_NE,
      BLUEGLOWLEFT,  ANYTHING,      BLUEGLOWRIGHT,
      BLUEGLOW_SW,   BLUEGLOWDOWN,  BLUEGLOW_SE
  } },
  { { YELLOWHEAD_NW, YELLOWHEADUP,  YELLOWHEAD_NE,
      YELLOWHEADLEFT,ANYTHING,      YELLOWHEADRIGHT,
      YELLOWHEAD_SW, YELLOWHEADDOWN,YELLOWHEAD_SE
    },
    { YELLOWGLOW_NW, YELLOWGLOWUP,  YELLOWGLOW_NE,
      YELLOWGLOWLEFT,ANYTHING,      YELLOWGLOWRIGHT,
      YELLOWGLOW_SW, YELLOWGLOWDOWN,YELLOWGLOW_SE
} } };

UBYTE eachtail[4][2][9][9] = {
{ { { GN_SE_NW,      GN_SE_N,       GN_SE_NE, // going NW (delta -1, -1)
      GN_SE_W,       WHATEVER,      GN_SE_E,  // (so starting from SE)
      GN_SE_SW,      GN_SE_S,       GN_SE_NW
    },
    { GN_S_NW,       GN_S_N,        GN_S_NE,  // going N (delta 0, -1)
      GN_S_W,        WHATEVER,      GN_S_E,   // (so starting from S)
      GN_S_SW,       GN_S_N,        GN_S_SE
    },
    { GN_SW_NW,      GN_SW_N,       GN_SW_NE, // going NE (delta 0, 1)
      GN_SW_W,       WHATEVER,      GN_SW_E,  // (so starting from SW)
      GN_SW_NE,      GN_SW_S,       GN_SW_SE
    },
    { GN_E_NW,       GN_E_N,        GN_E_NE,  // going W (delta -1, 0)
      GN_E_W,        WHATEVER,      GN_E_W,   // (so starting from E)
      GN_E_SW,       GN_E_S,        GN_E_SE
    },
    { GN_SE_NW,      GN_S_N,        GN_SW_NE, // going nowhere (delta 0, 0)
      GN_E_W,        WHATEVER,      GN_W_E,
      GN_NE_SW,      GN_N_S,        GN_NW_SE
    },
    { GN_W_NW,       GN_W_N,        GN_W_NE,  // going E (delta 1, 0)
      GN_W_E,        WHATEVER,      GN_W_E,   // (so starting from W)
      GN_W_SW,       GN_W_S,        GN_W_SE
    },
    { GN_NE_NW,      GN_NE_N,       GN_NE_NW, // going SW (delta -1, 1)
      GN_NE_W,       WHATEVER,      GN_NE_E,  // (so starting from NE)
      GN_NE_SW,      GN_NE_S,       GN_NE_SE
    },
    { GN_N_NW,       GN_N_S,        GN_N_NE,  // going S (delta 0, 1)
      GN_N_W,        WHATEVER,      GN_N_E,   // (so starting from N)
      GN_N_SW,       GN_N_S,        GN_N_SE
    },
    { GN_NW_SE,      GN_NW_N,       GN_NW_NE, // going SE (delta 1, 1)
      GN_NW_W,       WHATEVER,      GN_NW_E,  // (so starting from NW)
      GN_NW_SW,      GN_NW_S,       GN_NW_SE
  } },
  { { GG_SE_NW,      GG_SE_N,       GG_SE_NE, // going NW (delta -1, -1)
      GG_SE_W,       WHATEVER,      GG_SE_E,  // (so starting from SE)
      GG_SE_SW,      GG_SE_S,       GG_SE_NW
    },
    { GG_S_NW,       GG_S_N,        GG_S_NE,  // going N (delta 0, -1)
      GG_S_W,        WHATEVER,      GG_S_E,   // (so starting from S)
      GG_S_SW,       GG_S_N,        GG_S_SE
    },
    { GG_SW_NW,      GG_SW_N,       GG_SW_NE, // going NE (delta 0, 1)
      GG_SW_W,       WHATEVER,      GG_SW_E,  // (so starting from SW)
      GG_SW_NE,      GG_SW_S,       GG_SW_SE
    },
    { GG_E_NW,       GG_E_N,        GG_E_NE,  // going W (delta -1, 0)
      GG_E_W,        WHATEVER,      GG_E_W,   // (so starting from E)
      GG_E_SW,       GG_E_S,        GG_E_SE
    },
    { GG_SE_NW,      GG_S_N,        GG_SW_NE, // going nowhere (delta 0, 0)
      GG_E_W,        WHATEVER,      GG_W_E,
      GG_NE_SW,      GG_N_S,        GG_NW_SE
    },
    { GG_W_NW,       GG_W_N,        GG_W_NE,  // going E (delta 1, 0)
      GG_W_E,        WHATEVER,      GG_W_E,   // (so starting from W)
      GG_W_SW,       GG_W_S,        GG_W_SE
    },
    { GG_NE_NW,      GG_NE_N,       GG_NE_SW, // going SW (delta -1, 1)
      GG_NE_W,       WHATEVER,      GG_NE_E,  // (so starting from NE)
      GG_NE_SW,      GG_NE_S,       GG_NE_SE
    },
    { GG_N_NW,       GG_N_S,        GG_N_NE,  // going S (delta 0, 1)
      GG_N_W,        WHATEVER,      GG_N_E,   // (so starting from N)
      GG_N_SW,       GG_N_S,        GG_N_SE
    },
    { GG_NW_SE,      GG_NW_N,       GG_NW_NE, // going SE (delta 1, 1)
      GG_NW_W,       WHATEVER,      GG_NW_E,  // (so starting from NW)
      GG_NW_SW,      GG_NW_S,       GG_NW_SE
} } },
{ { { RN_SE_NW,      RN_SE_N,       RN_SE_NE, // going NW (delta -1, -1)
      RN_SE_W,       WHATEVER,      RN_SE_E,  // (so starting from SE)
      RN_SE_SW,      RN_SE_S,       RN_SE_NW,
    },
    { RN_S_NW,       RN_S_N,        RN_S_NE,  // going N (delta 0, -1)
      RN_S_W,        WHATEVER,      RN_S_E,   // (so starting from S)
      RN_S_SW,       RN_S_N,        RN_S_SE
    },
    { RN_SW_NW,      RN_SW_N,       RN_SW_NE, // going NE (delta 0, 1)
      RN_SW_W,       WHATEVER,      RN_SW_E,  // (so starting from SW)
      RN_SW_NE,      RN_SW_S,       RN_SW_SE
    },
    { RN_E_NW,       RN_E_N,        RN_E_NE,  // going W (delta -1, 0)
      RN_E_W,        WHATEVER,      RN_E_W,   // (so starting from E)
      RN_E_SW,       RN_E_S,        RN_E_SE
    },
    { RN_SE_NW,      RN_S_N,        RN_SW_NE, // going nowhere (delta 0, 0)
      RN_E_W,        WHATEVER,      RN_W_E,
      RN_NE_SW,      RN_N_S,        RN_NW_SE
    },
    { RN_W_NW,       RN_W_N,        RN_W_NE,  // going E (delta 1, 0)
      RN_W_E,        WHATEVER,      RN_W_E,   // (so starting from W)
      RN_W_SW,       RN_W_S,        RN_W_SE
    },
    { RN_NE_NW,      RN_NE_N,       RN_NE_SW, // going SW (delta -1, 1)
      RN_NE_W,       WHATEVER,      RN_NE_E,  // (so starting from NE)
      RN_NE_SW,      RN_NE_S,       RN_NE_SE
    },
    { RN_N_NW,       RN_N_S,        RN_N_NE,  // going S (delta 0, 1)
      RN_N_W,        WHATEVER,      RN_N_E,   // (so starting from N)
      RN_N_SW,       RN_N_S,        RN_N_SE
    },
    { RN_NW_SE,      RN_NW_N,       RN_NW_NE, // going SE (delta 1, 1)
      RN_NW_W,       WHATEVER,      RN_NW_E,  // (so starting from NW)
      RN_NW_SW,      RN_NW_S,       RN_NW_SE
  } },
  { { RG_SE_NW,      RG_SE_N,       RG_SE_NE, // going NW (delta -1, -1)
      RG_SE_W,       WHATEVER,      RG_SE_E,  // (so starting from SE)
      RG_SE_SW,      RG_SE_S,       RG_SE_NW
    },
    { RG_S_NW,       RG_S_N,        RG_S_NE,  // going N (delta 0, -1)
      RG_S_W,        WHATEVER,      RG_S_E,   // (so starting from S)
      RG_S_SW,       RG_S_N,        RG_S_SE
    },
    { RG_SW_NW,      RG_SW_N,       RG_SW_NE, // going NE (delta 0, 1)
      RG_SW_W,       WHATEVER,      RG_SW_E,  // (so starting from SW)
      RG_SW_NE,      RG_SW_S,       RG_SW_SE
    },
    { RG_E_NW,       RG_E_N,        RG_E_NE,  // going W (delta -1, 0)
      RG_E_W,        WHATEVER,      RG_E_W,   // (so starting from E)
      RG_E_SW,       RG_E_S,        RG_E_SE
    },
    { RG_SE_NW,      RG_S_N,        RG_SW_NE, // going nowhere (delta 0, 0)
      RG_E_W,        WHATEVER,      RG_W_E,
      RG_NE_SW,      RG_N_S,        RG_NW_SE
    },
    { RG_W_NW,       RG_W_N,        RG_W_NE,  // going E (delta 1, 0)
      RG_W_E,        WHATEVER,      RG_W_E,   // (so starting from W)
      RG_W_SW,       RG_W_S,        RG_W_SE
    },
    { RG_NE_NW,      RG_NE_N,       RG_NE_SW, // going SW (delta -1, 1)
      RG_NE_W,       WHATEVER,      RG_NE_E,  // (so starting from NE)
      RG_NE_SW,      RG_NE_S,       RG_NE_SE
    },
    { RG_N_NW,       RG_N_S,        RG_N_NE,  // going S (delta 0, 1)
      RG_N_W,        WHATEVER,      RG_N_E,   // (so starting from N)
      RG_N_SW,       RG_N_S,        RG_N_SE
    },
    { RG_NW_SE,      RG_NW_N,       RG_NW_NE, // going SE (delta 1, 1)
      RG_NW_W,       WHATEVER,      RG_NW_E,  // (so starting from NW)
      RG_NW_SW,      RG_NW_S,       RG_NW_SE
} } },
{ { { BN_NW_SE,      BN_N_SE,       BN_NE_SE, // going NW (delta -1, -1)
      BN_W_SE,       WHATEVER,      BN_E_SE,  // (so starting from SE)
      BN_SW_SE,      BN_S_SE,       BN_NW_SE
    },
    { BN_NW_S,       BN_N_S,        BN_NE_S,  // going N (delta 0, -1)
      BN_W_S,        WHATEVER,      BN_E_S,   // (so starting from S)
      BN_S_SW,       BN_N_S,        BN_S_SE
    },
    { BN_NW_SW,      BN_N_SW,       BN_NE_SW, // going NE (delta 0, 1)
      BN_W_SW,       WHATEVER,      BN_SW_E,  // (so starting from SW)
      BN_NE_SW,      BN_S_SW,       BN_SW_SE
    },
    { BN_NW_E,       BN_N_E,        BN_E_NE,  // going W (delta -1, 0)
      BN_W_E,        WHATEVER,      BN_W_E,   // (so starting from E)
      BN_SW_E,       BN_E_S,        BN_E_SE
    },
    { BN_NW_SE,      BN_N_S,        BN_NE_SW, // going nowhere (delta 0, 0)
      BN_W_E,        WHATEVER,      BN_W_E,
      BN_NE_SW,      BN_N_S,        BN_NW_SE
    },
    { BN_W_NW,       BN_N_W,        BN_W_NE,  // going E (delta 1, 0)
      BN_W_E,        WHATEVER,      BN_W_E,   // (so starting from W)
      BN_W_SW,       BN_W_S,        BN_W_SE
    },
    { BN_NW_NE,      BN_N_NE,       BN_NE_SW, // going SW (delta -1, 1)
      BN_W_NE,       WHATEVER,      BN_E_NE,  // (so starting from NE)
      BN_NE_SW,      BN_NE_S,       BN_NE_SE
    },
    { BN_N_NW,       BN_N_S,        BN_N_NE,  // going S (delta 0, 1)
      BN_N_W,        WHATEVER,      BN_N_E,   // (so starting from N)
      BN_N_SW,       BN_N_S,        BN_N_SE
    },
    { BN_SW_SE,      BN_N_NW,       BN_NW_NE, // going SE (delta 1, 1)
      BN_W_NW,       WHATEVER,      BN_NW_E,  // (so starting from NW)
      BN_NW_SW,      BN_NW_S,       BN_NW_SE
  } },
  { { BG_NW_SE,      BG_N_SE,       BG_NE_SE, // going NW (delta -1, -1)
      BG_W_SE,       WHATEVER,      BG_E_SE,  // (so starting from SE)
      BG_SW_SE,      BG_S_SE,       BG_NW_SE
    },
    { BG_NW_S,       BG_N_S,        BG_NE_S,  // going N (delta 0, -1)
      BG_W_S,        WHATEVER,      BG_E_S,   // (so starting from S)
      BG_S_SW,       BG_N_S,        BG_S_SE
    },
    { BG_NW_SW,      BG_N_SW,       BG_NE_SW, // going NE (delta 0, 1)
      BG_W_SW,       WHATEVER,      BG_SW_E,  // (so starting from SW)
      BG_NE_SW,      BG_S_SW,       BG_SW_SE
    },
    { BG_NE_E,       BG_N_E,        BG_NE_E,  // going W (delta -1, 0)
      BG_W_E,        WHATEVER,      BG_W_E,   // (so starting from E)
      BG_SW_E,       BG_E_S,        BG_E_SE
    },
    { BG_NW_SE,      BG_N_S,        BG_NE_SW, // going nowhere (delta 0, 0)
      BG_W_E,        WHATEVER,      BG_W_E,
      BG_NE_SW,      BG_N_S,        BG_NW_SE
    },
    { BG_NW_W,       BG_N_W,        BG_NE_W,  // going E (delta 1, 0)
      BG_W_E,        WHATEVER,      BG_W_E,   // (so starting from W)
      BG_W_SW,       BG_W_S,        BG_W_SE
    },
    { BG_NW_NE,      BG_N_NE,       BG_NE_SW, // going SW (delta -1, 1)
      BG_NE_W,       WHATEVER,      BG_NE_E,  // (so starting from NE)
      BG_NE_SW,      BG_NE_S,       BG_NE_SE
    },
    { BG_N_NW,       BG_N_S,        BG_N_NE,  // going S (delta 0, 1)
      BG_N_W,        WHATEVER,      BG_N_E,   // (so starting from N)
      BG_N_SW,       BG_N_S,        BG_N_SE
    },
    { BG_NW_SE,      BG_N_NW,       BG_NW_NE, // going SE (delta 1, 1)
      BG_NW_W,       WHATEVER,      BG_NW_E,  // (so starting from NW)
      BG_NW_SW,      BG_NW_S,       BG_NW_SE
} } },
{ { { YN_NW_SE,      YN_N_SE,       YN_NE_SE, // going NW (delta -1, -1)
      YN_W_SE,       WHATEVER,      YN_E_SE,  // (so starting from SE)
      YN_SW_SE,      YN_S_SE,       YN_NW_SE
    },
    { YN_NW_S,       YN_N_S,        YN_NE_S,  // going N (delta 0, -1)
      YN_W_S,        WHATEVER,      YN_S_E,   // (so starting from S)
      YN_S_SW,       YN_N_S,        YN_S_SE
    },
    { YN_NW_SW,      YN_N_SW,       YN_NE_SW, // going NE (delta 0, 1)
      YN_W_SW,       WHATEVER,      YN_E_SW,  // (so starting from SW)
      YN_NE_SW,      YN_S_SW,       YN_SW_SE
    },
    { YN_NW_E,       YN_N_E,        YN_NE_E,  // going W (delta -1, 0)
      YN_W_E,        WHATEVER,      YN_W_E,   // (so starting from E)
      YN_E_SW,       YN_S_E,        YN_E_SE
    },
    { YN_NW_SE,      YN_N_S,        YN_NE_SW, // going nowhere (delta 0, 0)
      YN_W_E,        WHATEVER,      YN_W_E,
      YN_NE_SW,      YN_N_S,        YN_NW_SE
    },
    { YN_NW_W,       YN_N_W,        YN_W_NE,  // going E (delta 1, 0)
      YN_W_E,        WHATEVER,      YN_W_E,   // (so starting from W)
      YN_W_SW,       YN_W_S,        YN_W_SE
    },
    { YN_NW_NE,      YN_N_NE,       YN_NE_SW, // going SW (delta -1, 1)
      YN_W_NE,       WHATEVER,      YN_NE_E,  // (so starting from NE)
      YN_NE_SW,      YN_NE_S,       YN_NE_SE
    },
    { YN_N_NW,       YN_N_S,        YN_N_NE,  // going S (delta 0, 1)
      YN_N_W,        WHATEVER,      YN_N_E,   // (so starting from N)
      YN_N_SW,       YN_N_S,        YN_N_SE
    },
    { YN_NW_SE,      YN_N_NW,       YN_NW_NE, // going SE (delta 1, 1)
      YN_NW_W,       WHATEVER,      YN_NW_E,  // (so starting from NW)
      YN_NW_SW,      YN_NW_S,       YN_NW_SE
  } },
  { { YG_NW_SE,      YG_N_SE,       YG_NE_SE, // going NW (delta -1, -1)
      YG_W_SE,       WHATEVER,      YG_E_SE,  // (so starting from SE)
      YG_SW_SE,      YG_S_SE,       YG_NW_SE
    },
    { YG_S_NW,       YG_N_S,        YG_S_NE,  // going N (delta 0, -1)
      YG_W_S,        WHATEVER,      YG_E_S,   // (so starting from S)
      YG_S_SW,       YG_N_S,        YG_S_SE
    },
    { YG_NW_SW,      YG_N_SW,       YG_NE_SW, // going NE (delta 0, 1)
      YG_W_SW,       WHATEVER,      YG_E_SW,  // (so starting from SW)
      YG_NE_SW,      YG_S_SW,       YG_SW_SE
    },
    { YG_E_NW,       YG_E_N,        YG_E_NE,  // going W (delta -1, 0)
      YG_W_E,        WHATEVER,      YG_W_E,   // (so starting from E)
      YG_E_SW,       YG_E_S,        YG_E_SE
    },
    { YG_NW_SE,      YG_N_S,        YG_NE_SW, // going nowhere (delta 0, 0)
      YG_W_E,        WHATEVER,      YG_W_E,
      YG_NE_SW,      YG_N_S,        YG_NW_SE
    },
    { YG_W_NW,       YG_N_W,        YG_W_NE,  // going E (delta 1, 0)
      YG_W_E,        WHATEVER,      YG_W_E,   // (so starting from W)
      YG_W_SW,       YG_W_S,        YG_W_SE
    },
    { YG_NW_NE,      YG_N_NE,       YG_NE_SW, // going SW (delta -1, 1)
      YG_W_NE,       WHATEVER,      YG_E_NE,  // (so starting from NE)
      YG_NE_SW,      YG_S_NE,       YG_NE_SE
    },
    { YG_N_NW,       YG_N_S,        YG_N_NE,  // going S (delta 0, 1)
      YG_N_W,        WHATEVER,      YG_E_N,   // (so starting from N)
      YG_N_SW,       YG_N_S,        YG_N_SE
    },
    { YG_NW_SE,      YG_N_NW,       YG_NW_NE, // going SE (delta 1, 1)
      YG_W_NW,       WHATEVER,      YG_E_NW,  // (so starting from NW)
      YG_NW_SW,      YG_S_NW,       YG_NW_SE
} } }
};

/* Rules for variable types:

SBYTE is used for field coordinates and queue indexes
UBYTE is used for field contents
SWORD is used for frequencies
ULONG is used for scores */

struct
{   ABOOL alive, visible;
    SBYTE x, y, deltax, deltay, pos, time, dir;
    UBYTE dormant, multi, speed, last, oldlast, species, hardness, frame,
          journey, going, then,
          type; // type is worm 0-3 (for drips, missiles, dogs and birds)
    SWORD freq;
    ULONG score;
} creature[CREATURES + 1];

// MODULE VARIABLES (used only within engine.c) ---------------------------

MODULE ABOOL banging  = FALSE,
             first    = TRUE,
             enclosed = FALSE,
             trainer;
MODULE UBYTE infector[FIELDX + 1][FIELDY + 1],
             ice,
             leveltype;
MODULE SBYTE numberx,
             numbery,
             number,
             treasurer;

// GLOBAL VARIABLES -------------------------------------------------------

ABOOL anims      = TRUE,
      clearthem  = FALSE,
      modified   = FALSE,
      randomflag = FALSE,
      randomarray[MAXLEVELS + 1],
      thick      = FALSE,
      turbo      = FALSE;
UBYTE board[MAXLEVELS + 1][FIELDX + 1][FIELDY + 1],
      field[FIELDX + 1][FIELDY + 1];
SBYTE a = GAMEOVER,
      players,
      level = 1, levels, reallevel, sourcelevel,
      startx[MAXLEVELS + 1], starty[MAXLEVELS + 1];
SWORD secondsleft, secondsperlevel;
TEXT  pathname[81],
      date[DATELENGTH + 1],
      times[TIMELENGTH + 1];
ULONG delay, r;

AGLOBAL struct HiScoreStruct  hiscore[HISCORES + 1];
AGLOBAL struct WormStruct     worm[4];
AGLOBAL struct TeleportStruct teleport[MAXLEVELS + 1][4];

MODULE ABOOL blocked(UBYTE which, SBYTE deltax, SBYTE deltay)
{   UBYTE c = field[xwrap(teleport[level][partner(which)].x + deltax)][ywrap(teleport[level][partner(which)].y + deltay)];
    if (c == STONE || c == METAL || c == GOAT || c == OCTOPUS)
        return TRUE;
    else return FALSE;
}

MODULE void bombblast(SBYTE triggerer, SBYTE player, SBYTE centrex, SBYTE centrey)
{   SBYTE counter, downy, downymax, leftx, leftxmax, rightx, rightxmax, strength, uppy, uppymax, x, y;

    effect(FXUSE_BOMB);
    strength = ADD_BOMB + arand(RAND_BOMB);

    leftxmax = centrex - strength;
    if (leftxmax < 0)
        leftxmax = 0;
    rightxmax = centrex + strength;
    if (rightxmax > FIELDX)
        rightxmax = FIELDX;
    uppymax = centrey - strength;
    if (uppymax < 0)
        uppymax = 0;
    downymax = centrey + strength;
    if (downymax > FIELDY)
        downymax = FIELDY;

    leftx = centrex;
    rightx = centrex;
    uppy = centrey;
    downy = centrey;
    for (counter = 1; counter <= strength; counter++)
    {   if (leftx > leftxmax)
        {   leftx--;
            for (y = uppy; y <= downy; y++)
                squareblast(triggerer, player, field[leftx][y], leftx, y, FALSE);
        }
        if (uppy > uppymax)
        {   uppy--;
            for (x = leftx; x <= rightx; x++)
                squareblast(triggerer, player, field[x][uppy], x, uppy, FALSE);
        }
        if (rightx < rightxmax)
        {   rightx++;
            for (y = downy; y >= uppy; y--)
                squareblast(triggerer, player, field[rightx][y], rightx, y, FALSE);
        }
        if (downy < downymax)
        {   downy++;
            for (x = rightx; x >= leftx; x--)
                squareblast(triggerer, player, field[x][downy], x, downy, FALSE);
}   }   }

MODULE void bounceoffcreature(UBYTE which, SBYTE x, SBYTE y)
{   UBYTE killed;

    if (field[x][y] == GOAT || field[x][y] == OCTOPUS || field[x][y] == FISH)
    {   killed = whichcreature(x, y, field[x][y], which);
        creature[killed].alive = FALSE;
        change(x, y, BONUS);
}   }

MODULE ABOOL bouncecreature(UBYTE which, SBYTE x, SBYTE y)
{   if
    (    field[x][y] == METAL
     ||  field[x][y] == STONE
     ||  field[x][y] == WOOD
     ||  field[x][y] == GOAT
     ||  field[x][y] == OCTOPUS
     ||  field[x][y] == FISH
     || (field[x][y] >= FIRSTTAIL && field[x][y] <= LASTTAIL)
    )
    {   return TRUE;
    } else
    {   return FALSE;
}   }

MODULE SBYTE bsign(SBYTE value)
{   if (value < 0)
        return (-1);
    elif (value > 0)
        return (1);
    else return (0);
}

MODULE void changefield(void)
{   SBYTE x, y;

    if (randomflag && a == PLAYGAME && level)
    {   do
        {    sourcelevel = arand(levels - 1) + 1;
        } while (randomarray[level]);
        randomarray[level] = TRUE;
    } else sourcelevel = level;

    for (x = 0; x <= FIELDX; x++)
        for (y = 0; y <= FIELDY; y++)
            field[x][y] = board[sourcelevel][x][y];
}

void clearhiscores(void)
{   SBYTE i;

    clearthem = FALSE;
    for (i = 0; i <= HISCORES; i++)
    {   hiscore[i].player = -1;
        hiscore[i].level = 0;
        hiscore[i].score = 0;
        hiscore[i].fresh = FALSE;
        hiscore[i].name[0] = 0;
        hiscore[i].time[0] = 0;
        hiscore[i].date[0] = 0;
}   }

MODULE void death(void)
{   SBYTE pain, player;
    UBYTE which;
    ABOOL slow;

    for (player = 0; player <= 3; player++)
    {   if (worm[player].lives)
        {   if (!worm[player].alive)
            {   slow = FALSE;
                pain = 0;
                if (worm[player].cause >= FIRSTTAIL && worm[player].cause <= LASTTAIL)
                {   if (player == worm[player].cause - FIRSTTAIL)
                        pain = PAIN_FRIENDLYTAIL;
                    else pain = PAIN_ENEMYTAIL;
                    slow = TRUE;
                } elif (worm[player].cause >= FIRSTGLOW && worm[player].cause <= LASTGLOW)
                {   pain = PAIN_GLOW;
                    slow = TRUE;
                } elif (worm[player].cause >= FIRSTFIRE && worm[player].cause <= LASTFIRE)
                    pain = PAIN_WORMFIRE;
                elif (worm[player].cause >= FIRSTHEAD && worm[player].cause <= LASTHEAD)
                    pain = PAIN_HEAD;
                elif (worm[player].cause >= FIRSTPROTECTOR && worm[player].cause <= LASTPROTECTOR)
                    pain = PAIN_PROTECTOR;
                elif (worm[player].cause >= FIRSTMISSILE && worm[player].cause <= LASTMISSILE)
                    pain = PAIN_MISSILE;
                elif (worm[player].cause >= FIRSTDRIP && worm[player].cause <= LASTDRIP)
                    pain = PAIN_DRIP;
                else switch (worm[player].cause)
                {
                case GOAT:
                    pain = PAIN_GOAT;
                    slow = TRUE;
                break;
                case OCTOPUS:
                    pain = PAIN_OCTOPUS;
                    slow = TRUE;
                break;
                case METAL:
                    pain = PAIN_METAL;
                    slow = TRUE;
                break;
                case SLIME:
                    pain = PAIN_SLIME;
                    slow = TRUE;
                break;
                case STONE:
                    pain = PAIN_STONE;
                    slow = TRUE;
                break;
                case TELEPORT:
                    pain = PAIN_TELEPORT;
                    slow = TRUE;
                break;
                case WOOD:
                    pain = PAIN_WOOD;
                    slow = TRUE;
                break;
                case BIRD:
                    pain = PAIN_BIRD;
                break;
                case BOMB:
                    pain = PAIN_BOMB;
                break;
                case CLOUD:
                    pain = PAIN_CLOUD;
                break;
                case DOG:
                    pain = PAIN_DOG;
                break;
                case FRAGMENT:
                    pain = PAIN_FRAGMENT;
                break;
                case LIGHTNING:
                    pain = PAIN_LIGHTNING;
                break;
                case ORB:
                    pain = PAIN_ORB;
                break;
                case OTTER:
                    pain = PAIN_OTTER;
                break;
                case PENGUIN:
                    pain = PAIN_PENGUIN;
                break;
                case SLAYER:
                    pain = PAIN_SLAYER;
                break;
                case WHIRLWIND:
                    pain = PAIN_WHIRLWIND;
                break;
                default:
                    // assert(0);
                break;
                }
                if (worm[player].victor >= 0 && worm[player].victor != player)
                {   if (worm[worm[player].victor].bias)
                    {   worm[worm[player].victor].lives += pain;
                        stat(worm[player].victor, LIFE);
                }   }
                if (slow)
                {   worm[player].speed = slowdown(worm[player].speed, worm[player].brakes);
                    stat(player, BRAKES);
                }
                if (pain > worm[player].lives)
                    worm[player].lives = 0;
                else worm[player].lives -= pain;

                draw(worm[player].x, worm[player].y, FIRSTPAIN + player);
                drawcause(player, NORMAL);
                stat(player, LIFE);
                if (level)
                    worm[player].levelreached = level;
                else worm[player].levelreached = reallevel;
                if (worm[player].lives)
                {   effect(FXPAIN + player);
                    worm[player].alive = TRUE;
                    worm[player].causewait = r + CAUSEWAIT;
                } else
                {   /* kill worm */
                    effect(FXDEATH_WORM);
                    change(worm[player].x, worm[player].y, FIRSTGRAVE + player);
                    updatearrow(worm[player].y);
                    for (which = 0; which <= PROTECTORS; which++)
                        if (protector[player][which].alive && protector[player][which].visible)
                            change(protector[player][which].x, protector[player][which].y, EMPTY);
                    for (which = 0; which <= MAGNETS; which++)
                        if (magnet[which].player == player)
                            magnet[which].alive = FALSE;
                    if (worm[player].score >= worm[player].hiscore)
                        worm[player].hiscore = worm[player].score;
    }   }   }   }

    if (!worm[0].lives && !worm[1].lives && !worm[2].lives && !worm[3].lives)
    {   /* End of game */
        for (player = 0; player <= 3; player++)
            if (worm[player].control != NONE && worm[player].score >= worm[player].hiscore)
                worm[player].hiscore = worm[player].score;
        newhiscores();
        effect(FXGAMEOVER);
        a = GAMEOVER;
        if (players == 1)
            say((STRPTR) "Game over!", worm[onlyworm(FALSE)].colour);
        elif (worm[0].control && ((!worm[1].control) || worm[1].score < worm[0].score) && ((!worm[2].control) || worm[2].score < worm[0].score) && ((!worm[3].control) || worm[3].score < worm[0].score))
            say((STRPTR) "Green wins!", GREEN);
        elif (worm[1].control && ((!worm[0].control) || worm[0].score < worm[1].score) && ((!worm[2].control) || worm[2].score < worm[1].score) && ((!worm[3].control) || worm[3].score < worm[1].score))
            say((STRPTR) "Red wins!", RED);
        elif (worm[2].control && ((!worm[0].control) || worm[0].score < worm[2].score) && ((!worm[1].control) || worm[1].score < worm[2].score) && ((!worm[3].control) || worm[3].score < worm[2].score))
            say((STRPTR) "Blue wins!", BLUE);
        elif (worm[3].control && ((!worm[0].control) || worm[0].score < worm[3].score) && ((!worm[1].control) || worm[1].score < worm[3].score) && ((!worm[2].control) || worm[2].score < worm[3].score))
            say((STRPTR) "Yellow wins!", YELLOW);
        else say((STRPTR) "A draw!", WHITE);
        waitasec();
        anykey(FALSE);
}   }

MODULE void drawcause(SBYTE player, SBYTE state)
{   if (state == BLACK)
    {   draw
        (   -6,
            (player * 10) + 8,
            BLACKENED
        );
    } else
    {   draw
        (   -6,
            (player * 10) + 8,
            worm[player].cause
        );
}   }

/* NAME    enginesetup -- once-only initialization of engine variables
SYNOPSIS   enginesetup(void);
FUNCTION   Sets up the unchanging worm variables.
MODULE     engine.c */

void enginesetup(void)
{   worm[0].statx = worm[0].staty = worm[1].staty = worm[2].statx = 0;
    worm[1].statx = worm[2].staty = worm[3].statx = worm[3].staty = 1;
    worm[0].colour = GREEN;
    worm[1].colour = RED;
    worm[2].colour = BLUE;
    worm[3].colour = YELLOW;
    worm[0].dimcolour = DARKGREEN;
    worm[1].dimcolour = DARKRED;
    worm[2].dimcolour = DARKBLUE;
    worm[3].dimcolour = DARKYELLOW;
    worm[0].port = 2;
    worm[1].port = 3;
    worm[2].port = 1;
    worm[3].port = 0;
    worm[0].name[0] = worm[1].name[0] = worm[2].name[0] = worm[3].name[0] = 0;
    worm[0].dynamitescore =
    worm[1].dynamitescore =
    worm[2].dynamitescore =
    worm[3].dynamitescore = 0;

    strcpy(pathname, DEFAULTSET);

    systemsetup();
}

/* NAME    fastloop -- things done often
SYNOPSIS   fastloop(void);
FUNCTION   Checks for and handles level completion.
MODULE     engine.c */

MODULE void fastloop(void)
{   SBYTE i, player, x, y;

    // all octopi spin together, but some may not be spinning, each may
    // be in a different part of its spin.
    if (!arand(FREQ_OCTOPUSSPIN))
    {   for (i = 0; i <= CREATURES; i++)
        {   if (creature[i].alive && creature[i].species == OCTOPUS && creature[i].dir >= 0)
            {   octopusfire(i);
    }   }   }

    // animate
    if (anims)
    {   for (i = 0; i <= CREATURES; i++)
        {   if (creature[i].alive && creature[i].visible)
            {   if (creature[i].species == BIRD)
                {   if (!(r % 3))
                    {   creature[i].frame += creature[i].dir;
                        draw(creature[i].x, creature[i].y, BIRD + creature[i].frame);
                        if (creature[i].frame == 0)
                        {   creature[i].dir = 1;
                        } elif (creature[i].frame == 4)
                        {   creature[i].dir = -1;
                }   }   }
                elif (creature[i].species == MISSILE)
                {   if (!(r % 3))
                    {   drawmissile(creature[i].x, creature[i].y, i);
                        if (++creature[i].frame > MISSILEFRAMES)
                        {   creature[i].frame = 0;
    }   }   }   }   }   }

    if (banging)
    {   banging = FALSE;
        for (x = 0; x <= FIELDX; x++)
            for (y = 0; y <= FIELDY; y++)
                if (field[x][y] == BANGDYNAMITE)
                {   change(x, y, SILVER);
                    bangdynamite(x, y, infector[x][y]);
                }
        for (i = 0; i <= 3; i++)
            if (worm[i].dynamitescore)
            {   wormscore(i, worm[i].dynamitescore);
                worm[i].dynamitescore = 0;
            }
        for (x = 0; x <= FIELDX; x++)
            for (y = 0; y <= FIELDY; y++)
                if (field[x][y] == TEMPBANGDYNAMITE)
                {   banging = TRUE;
                    field[x][y] = BANGDYNAMITE;
    }           }

    /* DYNAMITE PHILOSOPHY:

    Worm gets dynamite. Instantly the dynamite infects the surrounding
    dynamite into bang-dynamite.
        Each fastloop, you scan the field for bang-dynamite. For each
    piece you find, it turns to silver and infects any surrounding dynamite.

    flash letter */

    if (level)
    {   if (r % 8 == 1)
        {   draw(numberx, numbery, WHITENED);
        } elif (r % 8 == 2)
        {   draw(numberx, numbery, FIRSTLETTER + number - 1);
    }   }

    // flash icons
    for (player = 0; player <= 3; player++)
    {   icon(player, GLOW);
        icon(player, CUTTER);
}   }

MODULE ABOOL findempty(SBYTE* x, SBYTE* y, ABOOL mode)
{   SBYTE count = 0, xx, yy;
    UBYTE c;

    if (mode)
    {   do
        {   xx = arand(FIELDX);
            yy = arand(FIELDY);
            c  = field[xx][yy];
        } while ((c != SLIME && c != WOOD && c != STONE && c != METAL && (c < FIRSTTAIL || c > LASTTAIL)) && ++count < PATIENCE);
    } else
    {   do
        {   xx = arand(FIELDX);
            yy = arand(FIELDY);
            c  = field[xx][yy];
        } while ((c < FIRSTEMPTY || c > LASTEMPTY) && ++count < PATIENCE);
    }

    if (count < PATIENCE)
    {   *x = xx;
        *y = yy;
        return(TRUE);
    } else
    {   return(FALSE);
}   }

void gameloop(void)
{   SBYTE i, player;

    if (a == PLAYGAME)
    {   ReadGameports();
        fastloop();
        gameinput();
    }
    if (a == PLAYGAME)
    {   ReadGameports();
        for (player = 0; player <= 3; player++)
            if (worm[player].lives && !(r % worm[player].speed))
                wormloop(player);
    }
    if (a == PLAYGAME)
    {   ReadGameports();
        for (i = 0; i <= CREATURES; i++)
        {   if (creature[i].alive && !(r % creature[i].speed) && (!ice || creature[i].species == MISSILE || creature[i].species == FRAGMENT))
            {   creatureloop(i);
    }   }   }
    if (a == PLAYGAME)
    {   ReadGameports();
        if (!(r % SPEED_MAGNET))
        {   magnetloop();
        }
        death();
    }
    if (a == PLAYGAME)
    {   ReadGameports();
        if (!(r % VERYSLOW))
        {   slowloop();
    }   }
    timing();
}

MODULE void killall(void)
{   UBYTE i;

    for (i = 0; i <= CREATURES; i++)
        creature[i].alive = FALSE;
    for (i = 0; i <= MAGNETS; i++)
        magnet[i].alive = FALSE;
    teleport[level][2].alive = FALSE;
    teleport[level][3].alive = FALSE;
}

SBYTE loadfields(STRPTR fieldname)
{   SBYTE i, j, x, y;
    TEXT  IOBuffer[NAMELENGTH + 1];
    UBYTE ver;

#ifdef PLATFORM_IBM
    UBYTE amigaboard[AMIGAFIELDX + 1][FIELDY + 1];
#endif

    /* This routine is not entirely robust, especially regarding
    failures part way through reading. It is very trusting of its data;
    ie. it doesn't do any sanity checking.

    Provided that the fieldset was created with Worm Wars's built-in field
    editor, and the file is not corrupt, these failures should never
    happen anyway.

    open file */

    // say("Opening...", WHITE);

    if (!ZOpen(fieldname, FALSE))
        return 1; /* no harm done */

    /* read header

    say("Reading header...", WHITE);

    FSET 7.0#!
    0123456789

    # is the NULL terminator
    ! is levels */

    if (!ZRead(IOBuffer, 10))
    {    ZClose();
        return 2; /* no harm done */
    }
    if (!strcmp(IOBuffer, "FSET 7.0"))
    {   ver = 70;
    } elif (!strcmp(IOBuffer, "FSET 7.2"))
    {   ver = 72;
    } else
    {   ZClose();
        return 3; /* no harm done */
    }
    levels = IOBuffer[9];

    /* read high score table */

    // say("Reading high score table...", WHITE);

    for (i = 0; i <= HISCORES; i++)
    {   if (!ZRead(IOBuffer, 6))
        {    ZClose();
             return 4; /* incorrect levels */
        }
        hiscore[i].fresh                        =  FALSE;
        hiscore[i].player                       =  IOBuffer[0];
        hiscore[i].level                        =  IOBuffer[1];
        hiscore[i].score                        = (IOBuffer[2] * 16777216)
                                                + (IOBuffer[3] * 65536)
                                                + (IOBuffer[4] * 256)
                                                +  IOBuffer[5];

        if (!ZRead(IOBuffer, NAMELENGTH + 1))
        {   ZClose();
            return 5; /* incorrect levels, corrupted high scores */
        }
        for (j = 0; j <= NAMELENGTH; j++)
        {   hiscore[i].name[j]              = IOBuffer[j];
        }
        if (!ZRead(IOBuffer, TIMELENGTH + 1))
        {   ZClose();
            return 6; /* incorrect levels, corrupted high scores */
        }
        for (j = 0; j <= TIMELENGTH; j++)
        {   hiscore[i].time[j]      = IOBuffer[j];
        }
        if (!ZRead(IOBuffer, DATELENGTH + 1))
        {   ZClose();
            return 7; /* incorrect levels, corrupted high scores */
        }
        for (j = 0; j <= DATELENGTH; j++)
        {   hiscore[i].date[j]      = IOBuffer[j];
    }   }

    // say("Reading level data...", WHITE);

    /* read level data */

    for (i = 0; i <= levels; i++)
    {   if (!ZRead(IOBuffer, 8))
        {   ZClose();
            return 9;
            /* incorrect levels, corrupted high scores,
            incorrect startx, teleports, field data */
        }
        startx[i]            =  IOBuffer[0];
        starty[i]            =  IOBuffer[1];
        teleport[i][0].alive =  IOBuffer[2];
        teleport[i][0].x     =  IOBuffer[3];
        teleport[i][0].y     =  IOBuffer[4];
        teleport[i][1].alive =  IOBuffer[5];
        teleport[i][1].x     =  IOBuffer[6];
        teleport[i][1].y     =  IOBuffer[7];

#ifdef PLATFORM_AMIGA
        if (!ZRead((char *) &board[i][0][0], LEVELSIZE))
        {   ZClose();
            return 10;
            /* incorrect levels, corrupted high scores,
            incorrect startx, teleports, field data */
        }
#endif
#ifdef PLATFORM_IBM
        startx[i]        += 6;
        teleport[i][0].x += 6;
        teleport[i][0].y += 6;
        if (!ZRead((char *) &amigaboard[0][0], LEVELSIZE))
        {   ZClose();
            return 10;
            /* incorrect levels, corrupted high scores,
            incorrect startx, teleports, field data */
        }

        // skip 6
        for (x = 0; x <= 5; x++)
        {   {   for (y = 0; y <= FIELDY; y++)
                {   board[i][x][y] = EMPTY;
        }   }   }
        for (x = 0; x <= AMIGAFIELDX; x++)
        {   for (y = 0; y <= FIELDY; y++)
            {   board[i][x + 6][y] = amigaboard[x][y];
        }   }
        // skip 7
        for (x = AMIGAFIELDX + 6 + 1; x <= FIELDX; x++)
        {   for (y = 0; y <= FIELDY; y++)
            {   board[i][x][y] = EMPTY;
        }   }
#endif
        if (ver == 70)
        {   for (x = 0; x <= FIELDX; x++)
            {   for (y = 0; y <= FIELDY; y++)
                {   if (board[i][x][y] >= 6 && board[i][x][y] <= 19) // CLOCK thru MULTIPLIER
                    {   board[i][x][y]++;
                    } elif (board[i][x][y] == 20) // NITRO (BRAKES)
                    {   board[i][x][y] = 6;
    }   }   }   }   }

    // say("Open done.", WHITE);

    // no need to read version string
    ZClose();
    modified = FALSE;
    return 0;
}

MODULE void magnetloop(void)
{   SBYTE i;
    UBYTE c;

    for (i = 0; i <= MAGNETS; i++)
    {   if (magnet[i].alive)
        {   // defensive programming to ensure magnet is still valid
            if (field[magnet[i].x][magnet[i].y] != magnet[i].object)
            {   magnet[i].alive = FALSE;
            } else
            {   change(magnet[i].x, magnet[i].y, EMPTY);
                magnet[i].x += bsign(worm[magnet[i].player].x - magnet[i].x);
                magnet[i].y += bsign(worm[magnet[i].player].y - magnet[i].y);
                c = field[magnet[i].x][magnet[i].y];

                if
                (   (c >= FIRSTEMPTY && c <= LASTEMPTY)
                 || (c >= FIRSTTAIL  && c <= LASTTAIL)
                 || (c >= FIRSTGLOW  && c <= LASTGLOW)
                )
                {   change(magnet[i].x, magnet[i].y, magnet[i].object);
                } elif (c >= FIRSTHEAD && c <= LASTHEAD)
                {   change(magnet[i].x, magnet[i].y, magnet[i].object);
                    wormscore(c - FIRSTHEAD, wormobject(c - FIRSTHEAD, magnet[i].x, magnet[i].y));
                    change(magnet[i].x, magnet[i].y, FIRSTHEAD + magnet[i].player); // not entirely the right head image
                } else magnet[i].alive = FALSE;
}   }   }   }

AGLOBAL void matchteleports(void)
{   AUTO UWORD teleports, octopi;
    AUTO SBYTE x, y, i;

    say("Checking fieldset...", WHITE);
    for (i = 0; i <= levels; i++)
    {   teleports = octopi = 0;
        teleport[level][0].alive = teleport[level][1].alive = FALSE;

        for (y = 0; y <= FIELDY; y++)
        {   for (x = 0; x <= FIELDX; x++)
            {   if (board[level][x][y] == TELEPORT)
                {   teleports++;
                    if (teleports <= 2)
                    {   teleport[level][teleports - 1].x = x;
                        teleport[level][teleports - 1].y = y;
                    } else
                    {   board[level][x][y] = EMPTY;
                }   }
                elif (board[level][x][y] == OCTOPUS)
                {   octopi++;
                    if (octopi > OCTOPI)
                    {   board[level][x][y] = EMPTY;
        }   }   }   }

        if (teleports == 1)
        {   board[level][teleport[level][0].x][teleport[level][0].y] = EMPTY;
        } elif (teleports >= 2)
        {   teleport[level][0].alive = teleport[level][1].alive = TRUE;
}   }   }

AGLOBAL void newfield(void)
{   SBYTE x, y;

    teleport[level][0].alive = FALSE;
    teleport[level][1].alive = FALSE;
    startx[level] = CENTREX;
    starty[level] = CENTREY;

    if (level)
    {   for (x = 0; x <= FIELDX; x++)
        {   for (y = 0; y <= FIELDY; y++)
            {   board[level][x][y] = EMPTY;
    }   }   }
    else
    {   for (x = 0; x <= FIELDX; x++)
        {   for (y = 0; y <= FIELDY; y++)
            {   board[0][x][y] = SILVER;
}   }   }   }

void newfields(void)
{   if (verify())
    {   strcpy(pathname, DEFAULTSET);
        levels = DEFAULTLEVELS;
        modified = FALSE;
        for (level = 0; level <= levels; level++)
            newfield();
        clearhiscores();
        level = 1;
        if (a == FIELDEDIT)
        {   turborender();
            saylevel(WHITE);
        } else hiscores();
}   }

void newgame(void)
{   SBYTE i, player;

    players = 0;
    for (player = 0; player <= 3; player++)
    {   if (worm[player].control != NONE)
            players++;
        worm[player].lives = 0;
        worm[player].speed = NORMAL;
        worm[player].hiscore = 0;
    }
    for (i = 1; i <= MAXLEVELS; i++)
       randomarray[i] = FALSE;

    r         = -1;
    trainer   = FALSE;
    ice       = 0;
    reallevel = 0;
    level     = 1;
    a         = PLAYGAME;
    clearscreen();
    newlevel(arand(3));
    timing();
}

MODULE void newhiscores(void)
{   PERSIST TEXT  amiganame[4][NAMELENGTH + 1] = {"Jay Miner", "Carl Sassenrath", "R. J. Mical", "Dave Morse"};
    AUTO    SBYTE i, j, player;

    datestamp();
    for (player = 0; player <= 3; player++)
        for (i = 0; i <= HISCORES; i++)
            if (worm[player].control != NONE && worm[player].score >= hiscore[i].score)
            {   /* push all worse hiscores down */

                if (i < HISCORES)
                    for (j = HISCORES; j >= i + 1; j--)
                    {   hiscore[j].player     = hiscore[j - 1].player;
                        hiscore[j].level      = hiscore[j - 1].level;
                        hiscore[j].score      = hiscore[j - 1].score;
                        hiscore[j].fresh      = hiscore[j - 1].fresh;
                        strcpy(hiscore[j].name, hiscore[j - 1].name);
                        strcpy(hiscore[j].date, hiscore[j - 1].date);
                        strcpy(hiscore[j].time, hiscore[j - 1].time);
                    }
                modified = TRUE;
                hiscore[i].player = player;
                hiscore[i].level  = worm[player].levelreached;
                hiscore[i].score  = worm[player].hiscore;
                if (worm[player].control == AMIGA)
                {   strcpy(hiscore[i].name, amiganame[player]);
                    hiscore[i].fresh = FALSE;
                } else
                {   strcpy(hiscore[i].name, "(New)");
                    hiscore[i].fresh = TRUE;
                }
                strcpy(hiscore[i].time, times);
                strcpy(hiscore[i].date, date);
                break; /* vital */
}           }

MODULE void newlevel(UBYTE player)
{   SBYTE i, j;
    UWORD octopi = 0;
    UBYTE x, y;

    if (level >= 2)
        rundown(player);
    if (a == PLAYGAME)
    {   if (level > levels)
        {   for (i = 0; i <= 3; i++)
            {   if (worm[i].lives)
                    worm[i].levelreached = -1;
                if (worm[player].control != NONE && worm[player].score >= worm[player].hiscore)
                    worm[player].hiscore = worm[player].score;
            }
            celebrate();
            newhiscores();
            titlescreen();
        } else
        {   saylevel(WHITE);

            for (i = 0; i <= 3; i++)
            {   if (worm[i].multi > 1)
                {   worm[i].multi   /= 2;
                }
                worm[i].remnants =
                worm[i].encloser =
                worm[i].pusher   = FALSE;
            }
            killall();
            changefield();
            for (x = 0; x <= FIELDX; x++)
            {   for (y = 0; y <= FIELDY; y++)
                {   if (board[level][x][y] == OCTOPUS)
                    {   octopi++;
                        if (octopi <= OCTOPI)
                        {   for (i = 0; i <= CREATURES; i++)
                            {   if (!creature[i].alive)
                                {   createcreature(OCTOPUS, i, x, y, 0, 0, 255);
                                    break;
            }   }   }   }   }   }

            for (i = 0; i <= 3; i++)
            {   worm[i].speed = NORMAL;
                if (worm[i].lives)
                    stat(i, BRAKES);
                worm[i].moved = FALSE;
                worm[i].numbers = 0;
                worm[i].x = startx[sourcelevel];
                worm[i].y = starty[sourcelevel];
                worm[i].arrowy = worm[i].y;
        switch(i)
        {
        case 0:
            worm[0].deltax = -1;
            worm[0].deltay = 0;
        break;
        case 1:
            worm[1].deltax = 1;
            worm[1].deltay = 0;
        break;
        case 2:
            worm[2].deltax = 0;
            worm[2].deltay = -1;
        break;
        case 3:
            worm[3].deltax = 0;
            worm[3].deltay = 1;
        break;
        default:
        break;
            }   }
            turborender();
            delay = DELAY;
            if (level > 5)
            {   delay = delay / 4 * 3;
            }
            if (level > 10)
            {   delay = delay / 4 * 3;
            }
            if (level > 20)
            {   delay = delay / 4 * 3;
            }

            if (level)
            {   secondsperlevel = SECONDSPERLEVEL;

                number = 1;
                putnumber();

                for (i = 0; i <= 3; i++)
                {   if (!worm[i].lives && worm[i].control != NONE)
                    {   /* create (or resurrect) a worm */

                        worm[i].lives      = STARTLIVES;
                        worm[i].score      = 0;
                        worm[i].oldscore   = 0;
                        worm[i].armour     = 0;
                        worm[i].alive      = TRUE;
                        worm[i].power      = 0;
                        worm[i].bias       = 0;
                        worm[i].multi      = 1;
                        worm[i].victor     = -1;
                        worm[i].ammo       = 0;
                        worm[i].glow       = 0;
                        worm[i].remnants   =
                        worm[i].affixer    =
                        worm[i].sideshot   =
                        worm[i].pusher     =
                        worm[i].flashed    =
                        worm[i].encloser   =
                        worm[i].rammed     =
                        worm[i].frosted    =
                        worm[i].brakes      = FALSE;
                        worm[i].causewait  = (ULONG) -1;
                        worm[i].last       = FIRSTTAIL + i;
                        worm[i].pos        = -1;
                        worm[i].cutter     = 0;
                        worm[i].olddeltax  =
                        worm[i].olddeltay  = 0;
                        for (j = 0; j <= PROTECTORS; j++)
                        {   protector[i][j].alive = FALSE;
                        } for (j = 0; j <= LASTOBJECT; j++)
                        {   stat(i, j);
                            turbo = FALSE;
            }   }   }   }
            for (i = 0; i <= 3; i++)
            {   icon(i, REMNANTS);
                icon(i, AFFIXER);
                icon(i, SIDESHOT);
                icon(i, PUSHER);
                icon(i, GLOW);
                icon(i, CUTTER);
                icon(i, ENCLOSER);
    }   }   }
    clearkybd();
    resettime();
}

/* Many creatures take advantage of shared characteristics.
11 creature types (orbs, goats, drips, fragments, missiles, penguins,
cyclones, dogs, clouds, timebombs, octopus) use the creature structure.
Independent of it are worms, protectors, worm bullets and teleports. */

MODULE void creatureloop(SBYTE which)
{   ABOOL happy = FALSE;
    UBYTE bestdistance, distance, player, c, i;
    SBYTE x, y, xx, yy, xxx, yyy, frontx, fronty, rearx, reary,
          deltax, deltay;

    x = creature[which].x;
    y = creature[which].y;

    if (!valid(x, y)) // defensive programming
    {   creature[which].alive = FALSE;
        return;

        /* TEXT temp1[SAYLIMIT + 1], temp2[8];

        strcpy(temp1, "BAD CREATURE AT x: ");
        stci_d(temp2, x);
        strcat(temp1, temp2);
        strcat(temp1, ", y: ");
        stci_d(temp2, y);
        strcat(temp1, temp2);
        strcat(temp1, "!");
        say(temp1, PURPLE);
        draw(FIELDX + 1, 0, creature[which].species); // indicates which creature
        Delay(250);
        clearkybd();
        anykey(FALSE); */
    }

    /* decide whether and where to move */

    switch(creature[which].species)
    {
    case BIRD:
        if (creature[which].type == 255)
        {   bestdistance = 255;
            for (player = 0; player <= 3; player++)
            {   if (worm[player].lives && !worm[player].bias)
                {   xx = abs(worm[player].x - x);
                    yy = abs(worm[player].y - y);
                    if (xx > yy)
                        distance = xx;
                    else distance = yy;
                    if (distance <= DISTANCE_BIRD && distance < bestdistance)
                    {   effect(FXBORN_BIRD);
                        bestdistance = distance;
                        creature[which].type = player;
        }   }   }   }
        if (creature[which].type != 255) // if swooping
        {   if (worm[creature[which].type].lives && !worm[creature[which].type].bias)
            {   creature[which].deltax = bsign(worm[creature[which].type].x - x);
                creature[which].deltay = bsign(worm[creature[which].type].y - y);
            } else
            {   creature[which].type = 255; // return to dormancy
                creature[which].deltax = creature[which].deltay = 0;
        }   }
    break;
    case CLOUD:
        if (creature[which].x == 0 || creature[which].x == FIELDX)
            creature[which].deltax = -creature[which].deltax;
    break;
    case LION:
        if
        (   (creature[which].deltax == 0 && creature[which].deltay == 0)
        )
        {   if (arand(1) == 0)
            {   if (arand(1) == 0)
                {   creature[which].deltax = -1;
                } else
                {   creature[which].deltax =  1;
                }
                creature[which].deltay = 0;
            } else
            {   if (arand(1) == 0)
                {   creature[which].deltay = -1;
                } else
                {   creature[which].deltay =  1;
                }
                creature[which].deltax = 0;
        }   }
        elif (arand(FREQ_LIONTURN) == 0)
        {   if (creature[which].deltax)
            {   assert(creature[which].deltay == 0);
                creature[which].deltax = 0;
                if (arand(1) == 0)
                {   creature[which].deltay = -1;
                } else
                {   creature[which].deltay = 1;
                }
            } else
            {   assert(creature[which].deltay != 0);
                creature[which].deltay = 0;
                if (arand(1) == 0)
                {   creature[which].deltax = -1;
                } else
                {   creature[which].deltax = 1;
        }   }   }

        if (!valid(x + creature[which].deltax, y + creature[which].deltay))
        {   creature[which].deltax = -creature[which].deltax;
            creature[which].deltay = -creature[which].deltay;
        } else
        {   frontx = xwrap(x + creature[which].deltax);  /* look in front */
            fronty = ywrap(y + creature[which].deltay);
            if (bouncecreature(which, frontx, fronty))
            {   bounceoffcreature(which, frontx, fronty);
                creature[which].deltax = -creature[which].deltax;
                creature[which].deltay = -creature[which].deltay;
        }   }
    break;
    case OTTER:
        if (secondsleft)
        {   return;
        }
        if (creature[which].journey == OTTER_RIGHT)
        {   switch(creature[which].going)
            {
            case OTTER_DOWN:
                if (creature[which].y == FIELDY)
                {   if (creature[which].x == FIELDX)
                    {   creature[which].journey = OTTER_LEFT;
                        creature[which].going = OTTER_UP;
                    } else
                    {   creature[which].going = OTTER_RIGHT;
                        creature[which].then  = OTTER_UP;
                }   }
            break;
            case OTTER_RIGHT:
                creature[which].going = creature[which].then;
            break;
            case OTTER_UP:
                if (creature[which].y == 0)
                {   if (creature[which].x == FIELDX)
                    {   creature[which].journey = OTTER_LEFT;
                        creature[which].going = OTTER_DOWN;
                    } else
                    {   creature[which].going = OTTER_RIGHT;
                        creature[which].then  = OTTER_DOWN;
                }   }
            break;
            default:
            break;
        }   }
        else
        {   // assert(creature[which].journey == OTTER_LEFT);
            switch(creature[which].going)
            {
            case OTTER_DOWN:
                if (creature[which].y == FIELDY)
                {   if (creature[which].x == 0)
                    {   creature[which].journey = OTTER_RIGHT;
                        creature[which].going = OTTER_UP;
                    } else
                    {   creature[which].going = OTTER_LEFT;
                        creature[which].then  = OTTER_UP;
                }   }
            break;
            case OTTER_LEFT:
                creature[which].going = creature[which].then;
            break;
            case OTTER_UP:
                if (creature[which].y == 0)
                {   if (creature[which].x == 0)
                    {   creature[which].journey = OTTER_RIGHT;
                        creature[which].going = OTTER_DOWN;
                    } else
                    {   creature[which].going = OTTER_LEFT;
                        creature[which].then  = OTTER_DOWN;
                }   }
            break;
            default:
                // assert(0);
            break;
        }   }

        if (creature[which].going == OTTER_RIGHT)
        {   creature[which].deltax = 1;
            creature[which].deltay = 0;
        } elif (creature[which].going == OTTER_LEFT)
        {   creature[which].deltax = -1;
            creature[which].deltay = 0;
        } elif (creature[which].going == OTTER_UP)
        {   creature[which].deltax = 0;
            creature[which].deltay = -1;
        } elif (creature[which].going == OTTER_DOWN)
        {   creature[which].deltax = 0;
            creature[which].deltay = 1;
        }
    break;
    case TIMEBOMB:
    /* decrement and explode timebombs */
        if (field[x][y] != TIMEBOMB)
            creature[which].alive = FALSE;
        else
        {   effect(FXDO_BOMB);
            creature[which].time--;
            if (creature[which].time < 0)
            {   creature[which].alive = FALSE;
                bombblast(BOMB, 0, x, y);
                change(x, y, EMPTY);
            } else draw(x, y, ZERO + creature[which].time);
        }
        return; // not a bug
    break;
    case DOG:
        /* remove a movement from the dog queue */

        if (creature[which].dormant == CHASING)
        {   if (creature[which].pos != -1)
            {   creature[which].deltax = thedogqueue[which][0].deltax;
                creature[which].deltay = thedogqueue[which][0].deltay;
                if (--creature[which].pos != -1)
                {   for (i = 0; i <= creature[which].pos; i++)
                    {   thedogqueue[which][i].deltax = thedogqueue[which][i + 1].deltax;
                        thedogqueue[which][i].deltay = thedogqueue[which][i + 1].deltay;
            }   }   }
            else creature[which].alive = FALSE;
        }
    break;
    case PENGUIN:
    do
        {   xx = arand(2) - 1;
            yy = arand(2) - 1;
    } while (!valid(x + xx, y + yy));
        c = field[x + xx][y + yy];
        if (c >= FIRSTEMPTY && c <= LASTEMPTY)
        {   creature[which].deltax = xx;
            creature[which].deltay = yy;
    } else
        {   creature[which].deltax = 0;
            creature[which].deltay = 0;
    }
    break;
    case WHIRLWIND:
        /* Whirlwinds have a slight upwards drift.
        Higher values of WEIGHT make it less buoyant. */

        creature[which].deltax = arand(2) - 1;
        if (!arand(WEIGHT))
            creature[which].deltay = arand(1) - 1;
        else creature[which].deltay = arand(2) - 1;
    break;
    case MISSILE:
        bestdistance = 255;
        for (player = 0; player <= 3; player++)
        {   if (creature[which].type != player && worm[player].lives)
            {   xx = abs(worm[player].x - x);
                yy = abs(worm[player].y - y);
                if (xx < yy)
                    distance = xx;
                else distance = yy;
                if (distance < bestdistance)
                {   bestdistance = distance;
                    creature[which].deltax = bsign(worm[player].x - x);
                    creature[which].deltay = bsign(worm[player].y - y);
            }   }
            for (i = 0; i <= CREATURES; i++)
            {   if (creature[i].alive && which != i)
                {   if
                    (   (   creature[i].species != DRIP
                         && creature[i].species != MISSILE
                        )
                         || creature[i].type != creature[which].type
                    )
                    {   xx = abs(creature[i].x - x);
                        yy = abs(creature[i].y - y);
                        if (xx < yy)
                            distance = xx;
                        else distance = yy;
                        if (distance < bestdistance)
                        {   bestdistance = distance;
                            creature[which].deltax = bsign(creature[i].x - x);
                            creature[which].deltay = bsign(creature[i].y - y);
        }   }   }   }   }
        if (bestdistance == 255)
        {   creature[which].alive = FALSE;
            change(x, y, EMPTY);
        }
    break;
    case ORB:
        frontx  = xwrap(x + creature[which].deltax);  /* look in front */
        fronty  = ywrap(y + creature[which].deltay);
        rearx   = xwrap(x - creature[which].deltax);  /* look behind */
        reary   = ywrap(y - creature[which].deltay);
        if (bouncecreature(which, frontx, fronty))
        {   bounceoffcreature(which, frontx, fronty);
            xx = -creature[which].deltax; /* default bounce angle is 180° */
            yy = -creature[which].deltay;
            if (!bouncecreature(which, frontx, reary))
            {   if (bouncecreature(which, rearx, fronty))
                {   bounceoffcreature(which, rearx, fronty);
                    xx = creature[which].deltax;
            }   }
            elif (!bouncecreature(which, rearx, fronty))
            {   bounceoffcreature(which, rearx, fronty);
                yy = creature[which].deltay;
            }
            creature[which].deltax = xx;
            creature[which].deltay = yy;
        }
    break;
    case FISH:
    do
        {   xx = arand(2) - 1;
            yy = arand(2) - 1;
    } while (!valid(x + xx, y + yy));
        c = field[x + xx][y + yy];
        if (c == SLIME || c == WOOD || c == STONE || c == METAL || (c >= FIRSTTAIL && c <= LASTTAIL))
        {   creature[which].deltax = xx;
            creature[which].deltay = yy;
            creature[which].last = creature[which].oldlast;
            if (c >= FIRSTTAIL && c <= LASTTAIL)
            {   creature[which].oldlast = c - FIRSTTAIL + FIRSTGLOW;
            } else creature[which].oldlast = c;
        } else
        {   creature[which].deltax =
            creature[which].deltay = 0;
        }
    break;
    case GOAT:
        /* decide whether to move */
        if (!arand(FREQ_GOATMOVE))
        {   for (xx = x - 1; xx <= x + 1; xx++)
            {   for (yy = y - 1; yy <= y + 1; yy++)
                {   if (valid(xx, yy) && field[xx][yy] >= FIRSTEMPTY && field[xx][yy] <= LASTEMPTY)
                    {   happy = TRUE;
                        break;
        }   }   }   }
        creature[which].deltax =
        creature[which].deltay = 0;
        if (!happy)
        {   xx = arand(2) - 1;
            yy = arand(2) - 1;
            if (valid(x + xx, y + yy) && (xx || yy))
            {   c = field[x + xx][y + yy];
                if (c == SLIME || c == WOOD || c == STONE || c == METAL || (c >= FIRSTTAIL && c <= LASTTAIL))
                {   creature[which].last = creature[which].oldlast;
                    creature[which].oldlast = c;
                    creature[which].deltax = xx;
                    creature[which].deltay = yy;
        }   }   }
    break;
    default: // octopus, giraffe
    break;
    }

    /* now move */

    if (creature[which].deltax || creature[which].deltay)
    {   if (creature[which].visible)
    {   /* erase previous image */
            change(x, y, creature[which].last);
            if (creature[which].species == OTTER)
            {   if ((worm[0].lives && worm[0].bias)
                 || (worm[1].lives && worm[1].bias)
                 || (worm[2].lives && worm[2].bias)
                 || (worm[3].lives && worm[3].bias))
                 {   creature[which].last = DYNAMITE;
                 } else creature[which].last = STONE;
            } else
            {   creature[which].last = EMPTY;
        }   }
    if (creature[which].alive)
    {   creature[which].x += creature[which].deltax;
        creature[which].y += creature[which].deltay;
        if (creature[which].species == ORB)
        {   creature[which].x = xwrap(creature[which].x);
            creature[which].y = ywrap(creature[which].y);
            } elif
            (   creature[which].species == DOG
             || creature[which].species == DRIP
             || creature[which].species == FRAGMENT
             || creature[which].species == WHIRLWIND
            )
        {    if (!valid(creature[which].x, creature[which].y))
                {   creature[which].alive = FALSE;
    }   }   }   }

    creature[which].visible = TRUE;
    x = creature[which].x;
    y = creature[which].y;

    /* Collision detection. */

    if
    (    creature[which].alive
     &&  creature[which].species != FISH
     &&  creature[which].species != GIRAFFE
     &&  creature[which].species != GOAT
     &&  creature[which].species != PENGUIN
     &&  creature[which].species != OCTOPUS
     &&  creature[which].species != TIMEBOMB
     && (creature[which].deltax || creature[which].deltay)
    )
    {   c = field[x][y];

        if (c >= FIRSTHEAD && c <= LASTHEAD)
        {   wormcreature(c - FIRSTHEAD, which);
        } elif (c >= FIRSTPROTECTOR && c <= LASTPROTECTOR)
        {   protcreature(c - FIRSTPROTECTOR, which);
        } elif (c >= FIRSTTAIL && c <= LASTTAIL)
        {   ;
        } elif (c >= FIRSTLETTER && c <= LASTLETTER)
        {   creature[which].alive = FALSE;
        } elif (c == TIMEBOMB)
        {   if (creature[which].species != OTTER)
            {   creature[whichcreature(x, y, TIMEBOMB, which)].alive = FALSE;
            }
            bombblast(BOMB, 0, x, y);
            change(x, y, EMPTY);
        } elif (c >= FIRSTDRIP && c <= LASTDRIP)
        {   i = whichcreature(x, y, DRIP, which);
            creaturecreature(i, which);
        } elif (c >= FIRSTMISSILE && c <= LASTMISSILE)
        {   i = whichcreature(x, y, MISSILE, which);
            creaturecreature(which, i);
        } elif
        (   c == BIRD
         || c == DOG
         || c == CLOUD
         || c == FISH
         || c == FRAGMENT
         || c == GIRAFFE
         || c == GOAT
         || c == LION
         || c == OCTOPUS
         || c == ORB
         || c == OTTER
         || c == PENGUIN
         || c == WHIRLWIND
        )
        {   i = whichcreature(x, y, c, which);
            creaturecreature(which, i);
        } elif (c == METAL)
        {   if (creature[which].species == DRIP || creature[which].species == MISSILE || creature[which].species == CLOUD || creature[which].species == LION)
            {   creature[which].alive = FALSE;
            } elif (creature[which].species == FRAGMENT)
            {   reflect(which);
        }   }
        elif (c == STONE || c == WOOD)
        {   if
            (   creature[which].species == DRIP
             || creature[which].species == FRAGMENT
             || creature[which].species == MISSILE
             || creature[which].species == CLOUD
             || creature[which].species == LION
             || creature[which].species == ORB
            )
            {   effect(FXDEATH_FRAGMENT);
                creature[which].alive = FALSE;
        }   }
        elif (c == DYNAMITE)
        {   ;
        } elif (c >= FIRSTGRAVE && c <= LASTGRAVE)
        {   if (creature[which].species == ORB)
            {   effect(FXGET_SKULL);
            } elif (creature[which].species == FRAGMENT || creature[which].species == DRIP || creature[which].species == MISSILE || creature[which].species == CLOUD)
            {   effect(FXDEATH_FRAGMENT);
                creature[which].alive = FALSE;
        }   }
        elif (c == TELEPORT)
        {   /* Drips, fragments, missiles, orbs, whirlwinds, dogs, clouds, otters */
            i = whichteleport(x, y);
            if (creature[which].species != OTTER && blocked(i, creature[which].deltax, creature[which].deltay))
                creature[which].alive = FALSE;
            else
            {   effect(FXUSE_TELEPORT);
                creature[which].x = teleport[level][partner(i)].x + creature[which].deltax;
                creature[which].y = teleport[level][partner(i)].y + creature[which].deltay;

                if (creature[which].species == ORB)
                {   creature[which].x = xwrap(creature[which].x);
                    creature[which].y = ywrap(creature[which].y);
                } else
                {   if (!(valid(creature[which].x, creature[which].y)))
                        creature[which].alive = FALSE;
                    if (creature[which].species == FRAGMENT)
                        creature[which].last = SILVER;
        }   }   }
        elif (creature[which].species == ORB)
        {   if (c <= LASTOBJECT)
            {   if
                (   c == AMMO
                 || c == CYCLONE
                 || c == LIGHTNING
                 || c == BRAKES
                 || c == POWER
                 || c == PULSE
                 || c == SLAYER
                 || c == SLOWER
                 || c == ENCLOSER
                )
                {   creature[which].speed = speedup(creature[which].speed, TRUE);
                } elif (c == HEALER || c == LIFE || c == ICE || c == TREASURE || c == UMBRELLA || c == BONUS || c == ARMOUR)
                {   orbsplit(which);
                } else switch (c)
                {
                case BOMB:
                    draw(x, y, ORB);
                    bombblast(ORB, which, x, y);
                break;
                case PROTECTOR:
                    for (player = 0; player <= 3; player++)
                    {   if (worm[player].lives)
                        {   for (i = 0; i <= PROTECTORS; i++)
                            {  if (protector[player][i].alive)
                               {   protector[player][i].alive = FALSE;
                                   if (protector[player][i].visible)
                                   {   change(protector[player][i].x, protector[player][i].y, EMPTY);
                    }   }   }  }   }
                break;
                case MISSILE:
                case CONVERTER:
                    effect(FXGET_OBJECT);
                    for (i = 0; i <= CREATURES; i++)
                    {   if (creature[i].alive && creature[i].species == MISSILE)
                        {   creature[i].alive = FALSE;
                            change(x, y, EMPTY);
                    }   }
                break;
                case MULTIPLIER:
                    effect(FXGET_OBJECT);
                    creature[which].multi *= 2;
                    if (creature[which].multi > MULTILIMIT)
                        creature[which].multi = MULTILIMIT;
                break;
                case BIAS:
                    effect(FXGET_OBJECT);
                    for (player = 0; player <= 3; player++)
                        if (worm[player].lives && worm[player].bias)
                        {   worm[player].bias = 0;
                            stat(player, BIAS);
                        }
                break;
                case AFFIXER:
                    effect(FXGET_OBJECT);
                    for (player = 0; player <= 3; player++)
                        if (worm[player].lives)
                        {   worm[player].affixer = FALSE;
                            icon(player, AFFIXER);
                        }
                break;
                case REMNANTS:
                    effect(FXGET_OBJECT);
                    for (player = 0; player <= 3; player++)
                        if (worm[player].lives)
                        {   worm[player].remnants = FALSE;
                            icon(player, REMNANTS);
                        }
                break;
                case SIDESHOT:
                    effect(FXGET_POWERUP);
                    for (player = 0; player <= 3; player++)
                        if (worm[player].lives)
                        {   worm[player].sideshot = FALSE;
                            icon(player, SIDESHOT);
                        }
                break;
                case MAGNET:
                    effect(FXGET_OBJECT);
                    for (i = 0; i <= MAGNETS; i++)
                        if (magnet[i].alive)
                            magnet[i].alive = FALSE;
                break;
                case PUSHER:
                    effect(FXGET_OBJECT);
                    for (i = 0; i <= 3; i++)
                        if (worm[i].lives && worm[i].pusher)
                        {   worm[i].pusher = FALSE;
                            icon(i, PUSHER);
                        }
                break;
                case GLOW:
                    effect(FXGET_OBJECT);
                    for (xx = 0; xx <= FIELDX; xx++)
                        for (yy = 0; yy <= FIELDY; yy++)
                            if (field[xx][yy] >= FIRSTGLOW && field[xx][yy] <= LASTGLOW)
                                change(xx, yy, EMPTY);
                break;
                case SWITCHER:
                    effect(FXGET_OBJECT);
                    for (xx = 0; xx <= FIELDX; xx++)
                        for (yy = 0; yy <= FIELDY; yy++)
                            if (field[xx][yy] >= FIRSTTAIL && field[xx][yy] <= LASTTAIL)
                                change(xx, yy, WOOD);
                break;
                case GROWER:
                    effect(FXGET_GROWER);
                    for (xx = 0; xx <= FIELDX; xx++)
                        for (yy = 0; yy <= FIELDY; yy++)
                            if (field[xx][yy] == WOOD)
                                for (xxx = xx - 1; xxx <= xx + 1; xxx++)
                                    for (yyy = yy - 1; yyy <= yy + 1; yyy++)                                                                if (valid(xxx, yyy) && field[xxx][yyy] == EMPTY)
                                        field[xxx][yyy] = TEMPWOOD;
                    for (xx = 0; xx <= FIELDX; xx++)
                        for (yy = 0; yy <= FIELDY; yy++)
                            if (field[xx][yy] == TEMPWOOD)
                                change(xx, yy, WOOD);
                break;
                case CLOCK:
                    secondsperlevel -= arand(RAND_CLOCK);
                    if (secondsperlevel < 0)
                        secondsperlevel = 0;
                break;
                case CUTTER:
                    for (i = 0; i <= 3; i++)
                        if (worm[i].lives && worm[i].cutter)
                        {   worm[i].cutter = 0;
                            icon(i, CUTTER);
                        }
                break;
                default:
                    // assert(0);
                break;
    }   }   }   }

    x = creature[which].x; /* We refresh these in case a fragment has been */
    y = creature[which].y; /* reflected. Yes, it is vital. */

    if (creature[which].alive && creature[which].visible && (creature[which].deltax || creature[which].deltay))
    {   if (creature[which].species == MISSILE)
        {   drawmissile(x, y, which);
        } elif (creature[which].species == DRIP)
        {   change(x, y, FIRSTDRIP + creature[which].type);
        } else /* fragments, goats, penguins, cyclones, dogs, clouds, orbs, octopi, fish, otters */
        {   change(x, y, creature[which].species);
    }   }

    if (creature[which].alive)
    {   /* decide whether to fire */
        if (creature[which].species == GOAT)
        {   if (!arand(FREQ_GOATFIRE))
            {   for (i = 0; i <= CREATURES; i++)
                {   if (!creature[i].alive)
                    {   deltax = arand(2) - 1;
                        deltay = arand(2) - 1;
                        if (valid(x + deltax, y + deltay) && (deltax || deltay))
                        {   c = field[x + deltax][y + deltay];
                            if
                            (   (c >= FIRSTEMPTY && c <= LASTEMPTY)
                             || (c >= FIRSTTAIL && c <= LASTTAIL)
                            )
                            {   effect(FXDO_GOAT);
                                createcreature(FRAGMENT, i, x + deltax, y + deltay, deltax, deltay, 255);
                        }   }
                        break;
        }   }   }   }
        elif (creature[which].species == CLOUD)
        {   if (!arand(FREQ_CLOUDFIRE))
            {   cloudbullet(which, x, y, -1);
                cloudbullet(which, x, y, 1);
        }   }
        elif (creature[which].species == OCTOPUS)
        {   if (creature[which].dir == -1)
            {   if (!arand(FREQ_OCTOPUSFIRE))
                {   creature[which].dir = 0;
}   }   }   }   }

MODULE void cloudbullet(UBYTE which, SBYTE x, SBYTE y, SBYTE deltay)
{   UBYTE i, c;

    for (i = 0; i <= CREATURES; i++)
    {   if (!creature[i].alive)
        {   if (valid(x, y + deltay))
            {   c = field[x][y + deltay];
                if
                (   (c >= FIRSTEMPTY && c <= LASTEMPTY)
                ||  (c >= FIRSTTAIL && c <= LASTTAIL)
                )
                {   effect(FXDO_CLOUD);
                    createcreature(FRAGMENT, i, x, y + deltay, 0, deltay, 255);
            }   }
            break;
}   }   }

MODULE void orbsplit(SBYTE which)
{   SBYTE copy = 0, i;

    effect(FXDO_ORB);
    for (i = 0; i <= CREATURES; i++)
    {   if (!creature[i].alive)
        {   creature[i].x       = creature[which].x;
            creature[i].y       = creature[which].y;
            creature[i].score   = creature[which].score;
            creature[i].speed   = creature[which].speed;
            creature[i].multi   = creature[which].multi;
            creature[i].last    = EMPTY;
            creature[i].species = ORB;
            switch (copy)
            {
            case 0:
                if (creature[which].deltax != -1 || creature[which].deltay != -1)
                {   creature[i].deltax = -1;
                    creature[i].deltay = -1;
                    creature[i].alive = TRUE;
                }
            break;
            case 1:
                if (creature[which].deltax != 1 || creature[which].deltay != 1)
                {   creature[i].deltax = 1;
                    creature[i].deltay = 1;
                    creature[i].alive = TRUE;
                }
            break;
            case 2:
                if (creature[which].deltax != 1 || creature[which].deltay != -1)
                {   creature[i].deltax = 1;
                    creature[i].deltay = -1;
                    creature[i].alive = TRUE;
                }
            break;
            case 3:
                if (creature[which].deltax != -1 || creature[which].deltay != 1)
                {   creature[i].deltax = -1;
                    creature[i].deltay = 1;
                    creature[i].alive = TRUE;
                }
            break;
            default:
            break;
            }
            if (++copy >= 4)
                return;
}   }   }

SBYTE partner(SBYTE which)
{   if (which % 2 == 0)
        return((SBYTE) (which + 1));
    else return((SBYTE) (which - 1));
}

MODULE void putnumber(void)
{   SBYTE oldnumbery = numbery;
    ABOOL done;

    do
    {   done = findempty(&numberx, &numbery, FALSE);
    } while (!done);
    change(numberx, numbery, FIRSTLETTER + number - 1);
    updatearrow(oldnumbery);
    updatearrow(numbery);
}

/* NAME     queue -- adds a keystroke to the key queue
SYNOPSIS    name(SBYTE, SBYTE, SBYTE);
FUNCTION    Adds a keystroke to the in-game key queue.
INPUTS      player - player that pressed the key
            deltax - the deltax of the key
            deltay - the deltay of the key
IMPLEMENTATION
            thewormqueue[] array has WORMQUEUELIMIT as its last index.
            It is implemented as a FIFO stack rather than LIFO so that
            the keystrokes are processed in the correct order (that is,
            the order in which they were pressed). The oldest keystroke
            is always at index [0], the next oldest at [1], and so on
            upwards to the newest keystroke, at [worm[player].pos].
            Keystrokes are removed from the bottom of the array ([0]),
            and the rest of the array is shuffled down to fill the gap,
            so that the contents of [1] go to [0], the contents of [2]
            go to [1], etc. worm[player].pos is adjusted to always point
            to the newest entry, which is the 'end' of the queue.
MODULE      engine.c */

void wormqueue(SBYTE player, SBYTE deltax, SBYTE deltay)
{   if (worm[player].pos < WORMQUEUELIMIT)
    {   worm[player].pos++;
        thewormqueue[player][worm[player].pos].deltax = deltax;
        thewormqueue[player][worm[player].pos].deltay = deltay;
}   }

MODULE void dogqueue(SBYTE which, SBYTE deltax, SBYTE deltay)
{   if (creature[which].pos < DOGQUEUELIMIT)
    {   creature[which].pos++;
        thedogqueue[which][creature[which].pos].deltax = deltax;
        thedogqueue[which][creature[which].pos].deltay = deltay;
    } else
    {   creature[which].alive = FALSE;
        change(creature[which].x, creature[which].y, EMPTY);
}   }

MODULE void reflect(UBYTE which)
{   creature[which].deltax  = -creature[which].deltax;
    creature[which].deltay  = -creature[which].deltay;
    creature[which].x      +=  creature[which].deltax * 2;
    creature[which].y      +=  creature[which].deltay * 2;
}

ABOOL savefields(STRPTR fieldname)
{   SBYTE i, j;
    TEXT  IOBuffer[NAMELENGTH + 1];

#ifdef PLATFORM_IBM
    SBYTE x, y;
    UBYTE amigaboard[AMIGAFIELDX + 1][FIELDY + 1];
#endif

    matchteleports();

    if (!ZOpen(fieldname, TRUE))
    {   return FALSE;
    }

    /* write header */

    strcpy(IOBuffer, "FSET 7.2");
    IOBuffer[9] = levels;
    if (!ZWrite(IOBuffer, 10))
    {   ZClose();
        return FALSE;
    }

    /* write high score table */

    for (i = 0; i <= HISCORES; i++)
    {   IOBuffer[0]                                             =  hiscore[i].player;
        IOBuffer[1]                                             =  hiscore[i].level;

        IOBuffer[2]                                             =   hiscore[i].score / 16777216;
        IOBuffer[3]                                             =  (hiscore[i].score % 16777216) / 65536;
        IOBuffer[4]                                             = ((hiscore[i].score % 16777216) % 65536) / 256;
        IOBuffer[5]                                             = ((hiscore[i].score % 16777216) % 65536) % 256;
        if (!ZWrite(IOBuffer, 6))
        {   ZClose();
            return FALSE;
        }

        for (j = 0; j <= NAMELENGTH; j++)
            IOBuffer[j]                                         = hiscore[i].name[j];
        if (!ZWrite(IOBuffer, NAMELENGTH + 1))
        {   ZClose();
            return FALSE;
        }
        for (j = 0; j <= TIMELENGTH; j++)
            IOBuffer[j]                                             = hiscore[i].time[j];
        if (!ZWrite(IOBuffer, TIMELENGTH + 1))
        {   ZClose();
            return FALSE;
        }
        for (j = 0; j <= DATELENGTH; j++)
            IOBuffer[j]                                             = hiscore[i].date[j];
        if (!ZWrite(IOBuffer, DATELENGTH + 1))
        {   ZClose();
            return FALSE;
    }   }

    /* write level data */

    for (i = 0; i <= levels; i++)
    {   IOBuffer[0]                        = startx[i];
        IOBuffer[1]                        = starty[i];
        IOBuffer[2]                                             = teleport[i][0].alive;
        IOBuffer[3]                                             = teleport[i][0].x;
        IOBuffer[4]                                             = teleport[i][0].y;
        IOBuffer[5]                                             = teleport[i][1].alive;
        IOBuffer[6]                                             = teleport[i][1].x;
        IOBuffer[7]                                             = teleport[i][1].y;

#ifdef PLATFORM_IBM
        IOBuffer[0] -= 6;
        IOBuffer[3] -= 6;
        IOBuffer[6] -= 6;
#endif

        if (!ZWrite(IOBuffer, 8))
        {   ZClose();
            return FALSE;
        }

#ifdef PLATFORM_AMIGA
        if (!ZWrite((char *) &board[i][0][0], LEVELSIZE))
        {   ZClose();
            return FALSE;
        }
#endif
#ifdef PLATFORM_IBM
        for (x = 0; x <= AMIGAFIELDX; x++)
        {   for (y = 0; y <= FIELDY; y++)
            {   amigaboard[x][y] = board[i][x + 6][y];
        }   }

        if (!ZWrite((char *) &amigaboard[0][0], LEVELSIZE))
        {   ZClose();
            return FALSE;
        }
#endif
    }

    /* write version string */

    if (!ZWrite(VERSION, strlen(VERSION)))
    {   ZClose();
        return FALSE;
    }

    ZClose();

    if (clearthem)
        clearhiscores();
    modified = FALSE;
    return TRUE;
}

void saylevel(COLOUR colour)
{   TEXT mainstring[15] = "Level ", tempstring[4];

    if (level > 0)
    {   stci_d(&mainstring[6], level);
        strcat((char*) mainstring, " of ");
        stci_d(tempstring, levels);
        strcat((char*) mainstring, (char*) tempstring);
        say(mainstring, colour);
    } else
    {   if (a == FIELDEDIT)
        {   say("Bonus Level", colour);
        } elif (leveltype == TREASURE)
        {   say("Bonus Level: Treasury!", colour);
        } elif (leveltype == DRIP)
        {   say("Bonus Level: Drips!", colour);
        } else
        {   // assert(leveltype == PENGUIN);
            say("Bonus Level: Penguins!", colour);
}   }   }

MODULE SBYTE slowdown(SBYTE speed, ABOOL brakes)
{   speed *= 2;
    if (brakes)
    {   if (speed > VERYSLOW)
            speed = VERYSLOW;
    } elif (speed > SLOW)
        speed = SLOW;
    return(speed);
}

MODULE void slowloop(void)
{   SBYTE i, player, which, x, xx, y, yy;
    UBYTE c;
    ABOOL ok;

    if (ice)
    {   ice--;
    }

    /* decrement worm strength */

    for (player = 0; player <= 3; player++)
    {   if (worm[player].lives)
        {   if (worm[player].bias > 0)
            {   worm[player].bias--;
                stat(player, BIAS);
            }
            if (worm[player].cutter > 0)
            {   worm[player].cutter--;
                icon(player, CUTTER);
            }
            if (worm[player].glow > 0)
            {   worm[player].glow--;
                icon(player, GLOW);
            }
            if (worm[player].armour > 0)
            {   worm[player].armour--;
                stat(player, ARMOUR);
    }   }   }

    /* blank out old causes */

    for (player = 0; player <= 3; player++)
    {   if (worm[player].lives > 0 && r > worm[player].causewait)
        {   drawcause(player, BLACK);
            worm[player].causewait = (ULONG) -1; /* most future time possible */
    }   }

if (!ice)
{   if (level)
    {   /* create goats */
        if
        (   (!arand(FREQ_GOAT))
        &&  findempty(&x, &y, TRUE)
        )
        {   for (i = 0; i <= CREATURES; i++)
            {   if (!creature[i].alive)
                {   createcreature(GOAT, i, x, y, 0, 0, 255);
                    break;
        }   }   }
        /* create octopi */
        if
        (   (!arand(FREQ_OCTOPUS))
        &&  findempty(&x, &y, TRUE)
        )
        {   for (i = 0; i <= CREATURES; i++)
            {   if (!creature[i].alive)
                {   createcreature(OCTOPUS, i, x, y, 0, 0, 255);
                    break;
        }   }   }
        /* create fish */
        if
        (   (!arand(FREQ_FISH))
        &&  findempty(&x, &y, TRUE)
        )
        {   for (i = 0; i <= CREATURES; i++)
            {   if (!creature[i].alive)
                {   createcreature(FISH, i, x, y, 0, 0, 255);
                    break;
        }   }   }
        /* create orbs */
        if (!arand(FREQ_ORB) && findempty(&x, &y, FALSE))
        {   for (i = 0; i <= CREATURES; i++)
            {   if (!creature[i].alive)
                {   createcreature(ORB, i, x, y, (arand(1) * 2) - 1, (arand(1) * 2) - 1, 255);
                    break;
        }   }   }
        /* create dogs */
        if (!arand(FREQ_DOG) && findempty(&x, &y, FALSE))
        {   for (i = 0; i <= CREATURES; i++)
            {   if (!(creature[i].alive))
                {   createcreature(DOG, i, x, y, 0, 0, 255);
                    break;
        }   }   }
        /* create giraffes */
        if (!arand(FREQ_GIRAFFE) && findempty(&x, &y, FALSE))
        {   for (i = 0; i <= CREATURES; i++)
            {   if (!(creature[i].alive))
                {   createcreature(GIRAFFE, i, x, y, 0, 0, 255);
                    break;
        }   }   }
        /* create lions */
        if (!arand(FREQ_LION) && findempty(&x, &y, FALSE))
        {   for (i = 0; i <= CREATURES; i++)
            {   if (!(creature[i].alive))
                {   createcreature(LION, i, x, y, 0, 0, 255);
                    break;
        }   }   }
        /* create slime */
        if (!arand(FREQ_SLIME) && findempty(&x, &y, FALSE))
            change(x, y, SLIME);
        /* grow slime */
        if (!arand(FREQ_SLIMEGROW))
        {   for (x = 0; x <= FIELDX; x++)
                for (y = 0; y <= FIELDY; y++)
                    if (field[x][y] == SLIME)
                        for (xx = x - 1; xx <= x + 1; xx++)
                            for (yy = y - 1; yy <= y + 1; yy++)
                                if (valid(xx, yy) && field[xx][yy] == EMPTY && !arand(1))
                                    field[xx][yy] = TEMPSLIME;
            for (x = 0; x <= FIELDX; x++)
                for (y = 0; y <= FIELDY; y++)
                    if (field[x][y] == TEMPSLIME)
                        change(x, y, SLIME);
        }
        /* create timebombs */
        if (!arand(FREQ_TIMEBOMB) && findempty(&x, &y, FALSE))
        {   for (i = 0; i <= CREATURES; i++)
            {   if (!(creature[i].alive))
                {   createcreature(TIMEBOMB, i, x, y, 0, 0, 255);
                    break;
    }   }   }   }

    /* create drips */
    if
    (   ( level && !arand(FREQ_DRIP))
     || (!level && leveltype == DRIP && !arand(FREQ_DRIP / BONUSSPEEDUP))
    )
    {   x = arand(FIELDX);
        y = arand(2);
        c = field[x][y];
        if (c >= FIRSTEMPTY && c <= LASTEMPTY)
        {   for (i = 0; i <= CREATURES; i++)
            {   if (!creature[i].alive)
                {   createcreature(DRIP, i, x, y, 0, 1, (UBYTE) ((r / 16) % 4));
                    break;
    }   }   }   }
    // create penguins
    if
    (   (   ( level && !arand(FREQ_PENGUIN))
         || (!level && leveltype == PENGUIN && !arand(FREQ_PENGUIN / BONUSSPEEDUP))
        )
     && findempty(&x, &y, FALSE)
    )
    {   for (i = 0; i <= CREATURES; i++)
        {   if (!(creature[i].alive))
            {   createcreature(PENGUIN, i, x, y, 0, 0, 255);
                break;
    }   }   }
    // create birds
    if
    (  (level && !arand(FREQ_BIRD) && findempty(&x, &y, FALSE))
    )
    {   // check whether this location is far enough away from the worms
        ok = TRUE;
        for (i = 0; i <= 3; i++)
        {   if
            (   worm[i].lives
             && abs(worm[i].x - x) < DISTANCE_BIRD * 2
             && abs(worm[i].y - y) < DISTANCE_BIRD * 2
            )
            {   ok = FALSE;
                break;
        }   }
        if (ok)
        {   for (i = 0; i <= CREATURES; i++)
            {   if (!(creature[i].alive))
                {   createcreature(BIRD, i, x, y, 0, 0, 255);
                    break;
    }   }   }   }
    /* create clouds */
    if
    (   (   ( level && !arand(FREQ_CLOUD))
         || (!level && leveltype == CLOUD && !arand(FREQ_CLOUD / BONUSSPEEDUP))
        )
     && findempty(&x, &y, FALSE)
    )
    {   for (i = 0; i <= CREATURES; i++)
        {   if (!creature[i].alive)
            {   if (x < FIELDX / 2)
                {   createcreature(CLOUD, i, x, y, -1, 0, 255);
                } else
                {   createcreature(CLOUD, i, x, y,  1, 0, 255);
                }
                break;
    }   }   }

    /* create objects */
    for (which = 0; which <= LASTOBJECT; which++)
        if (level || leveltype != TREASURE || which == TREASURE)
        {   if (!arand(object[which].freq) && findempty(&x, &y, FALSE))
                change(x, y, which);
        } elif (!arand(object[which].freq / 10) && findempty(&x, &y, FALSE))
            change(x, y, which);

    /* create teleports */
    if (!arand(FREQ_TELEPORT)
    && !teleport[level][2].alive
    && findempty(&(teleport[level][2].x), &(teleport[level][2].y), FALSE)
    && findempty(&(teleport[level][3].x), &(teleport[level][3].y), FALSE)
    && (teleport[level][2].x != teleport[level][3].x || teleport[level][2].y != teleport[level][3].y))
    {   teleport[level][2].alive = TRUE;
        teleport[level][3].alive = TRUE;
        change(teleport[level][2].x, teleport[level][2].y, TELEPORT);
        change(teleport[level][3].x, teleport[level][3].y, TELEPORT);
}   }
}

MODULE SBYTE speedup(SBYTE speed, ABOOL brakes)
{   speed /= 2;
    if (speed < FAST)
        speed = FAST;
    return(speed);
}

MODULE void squareblast(SBYTE type, SBYTE player, UBYTE c, SBYTE x, SBYTE y, ABOOL cutter)
{   SBYTE which;
    UBYTE filler;

    if (type == HEAD && worm[player].bias && (!cutter))
    {   filler = DYNAMITE;
    } else filler = EMPTY;

    if (c <= LASTOBJECT)
    {   if (!cutter)
        {   change(x, y, filler);
    }   }
    elif ((c >= FIRSTTAIL && c <= LASTTAIL) || c == WOOD || c == SLIME)
    {   change(x, y, filler);
    } elif (c >= FIRSTHEAD && c <= LASTHEAD)
    {   if (!cutter && (type != HEAD || player != c - FIRSTHEAD))
        {   if (worm[c - FIRSTHEAD].armour == 0)
            {   worm[c - FIRSTHEAD].cause = BOMB;
                worm[c - FIRSTHEAD].alive = FALSE;
                if (type == HEAD)
                {   worm[c - FIRSTHEAD].victor = player;
                } else
                {   worm[c - FIRSTHEAD].victor = -1;
            }   }
            else
            {   effect(FXUSE_ARMOUR);
    }   }   }
    elif (c >= FIRSTMISSILE && c <= LASTMISSILE)
    {   which = whichcreature(x, y, MISSILE, 255);
        if (!cutter)
        {   if (type == HEAD)
            {   if (player != c - FIRSTMISSILE)
                {   wormkillcreature(player, which);
                    change(x, y, filler);
        }   }   }
        else
        {   creature[which].alive = FALSE;
            change(x, y, filler);
    }    }
    elif (c >= FIRSTDRIP && c <= LASTDRIP)
    {   if (!cutter)
        {   which = whichcreature(x, y, DRIP, 255);
            if (type == HEAD)
            {   wormkillcreature(player, which);
            } else
            {   creature[which].alive = FALSE;
            }
            change(x, y, filler);
    }   }
    elif
    (   c == CLOUD
     || c == DOG
     || c == FISH
     || c == FRAGMENT
     || c == GIRAFFE
     || c == GOAT
     || c == LION
     || c == OCTOPUS
     || c == ORB
     || c == PENGUIN
     || c == WHIRLWIND
    )
    {   if (!cutter)
        {   which = whichcreature(x, y, c, 255);
            if (type == HEAD)
            {   wormkillcreature(player, which);
            } else
            {   creature[which].alive = FALSE;
            }
            change(x, y, filler);
}   }   }

void timeloop(void)
{   AUTO    TEXT  timedisplay[5] = {"#:##"};
    AUTO    UBYTE i;
    AUTO    SBYTE y;
    PERSIST ABOOL expired        = FALSE;

    secondsleft = atleast(secondsleft, 0);
    timedisplay[0] = 48 +  (secondsleft / 60);
    timedisplay[2] = 48 + ((secondsleft % 60) / 10);
    timedisplay[3] = 48 + ((secondsleft % 60) % 10);

    if (!level)
    {   say(timedisplay, worm[treasurer].colour);
        if (!secondsleft)
        {   level = reallevel + 1;
            secondsleft = SECONDSPERLEVEL;
            newlevel(treasurer);
    }   }
    elif (!secondsleft)
    {   if (!expired)
        {   effect(FXSIREN);
            say("Time expired!", WHITE);
            expired = TRUE;

            // create otters
            for (i = 0; i <= CREATURES; i++)
            {   if (!creature[i].alive)
                {   for (y = 0; y <= FIELDY - 1; y++)
                    {   if (field[0][y] >= FIRSTEMPTY && field[0][y] <= LASTEMPTY)
                        {   createcreature(OTTER, i, 0,      y, 0,  1, 255);
                            break;
                    }   }
                    break;
            }   }
            for (i = 0; i <= CREATURES; i++)
            {   if (!creature[i].alive)
                {   for (y = FIELDY; y >= 1; y--)
                    {   if (field[FIELDX][y] >= FIRSTEMPTY && field[FIELDX][y] <= LASTEMPTY)
                        {   createcreature(OTTER, i, FIELDX, y, 0, -1, 255);
                            break;
                    }   }
                    break;
    }   }   }   }
    else
    {   expired = FALSE;
        say(timedisplay, WHITE);
}   }

void train(SCANCODE scancode)
{   SBYTE x, y;

    switch(scancode)
    {
    case HELP:
        trainer = !trainer;
    break;
    case NUMERICSLASH:
        /* Complete the level. */
        if (trainer)
        {   trainer = FALSE;
            endoflevel();
        }
    break;
    case NUMERICASTERISK:
        /* field[][] dump, for debugging purposes. */
        if (trainer)
        {   trainer = FALSE;
            say("Field dump...", PURPLE);
            for (x = 0; x <= FIELDX; x++)
                for (y = 0; y <= FIELDY; y++)
                    draw(x, y, field[x][y]);
            anykey(FALSE);
        }
        break;
    case NUMERICPLUS:
        if (trainer)
        {   trainer = FALSE;
            say("Trainer activated!", PURPLE);
            anykey(FALSE);
            if (worm[1].lives > 0)
            {   worm[1].lives = LIVESLIMIT;
                stat(1, LIFE);
                worm[1].armour = ARMOURLIMIT;
                stat(1, ARMOUR);
                worm[1].bias = BIASLIMIT;
                stat(1, BIAS);
                worm[1].ammo = AMMOLIMIT;
                stat(1, AMMO);
                worm[1].power = POWERLIMIT;
                stat(1, POWER);
                worm[1].brakes = TRUE;
                stat(1, BRAKES);
                worm[1].affixer = TRUE;
                icon(1, AFFIXER);
                worm[1].remnants = TRUE;
                icon(1, REMNANTS);
                worm[1].sideshot = TRUE;
                icon(1, SIDESHOT);
                worm[1].pusher = TRUE;
                icon(1, PUSHER);
                worm[1].cutter = 100;
                icon(1, CUTTER);
                worm[1].encloser = TRUE;
                icon(1, ENCLOSER);
                trainer = FALSE;
        }   }
    break;
    default:
    break;
}   }

MODULE void turnworm(SBYTE player, SBYTE deltax, SBYTE deltay)
{   if (worm[player].deltax == deltax && worm[player].deltay == deltay)
    {   worm[player].speed = speedup(worm[player].speed, worm[player].brakes);
        stat(player, BRAKES);
    } elif (worm[player].deltax == -deltax && worm[player].deltay == -deltay)
    {   worm[player].speed = slowdown(worm[player].speed, worm[player].brakes);
        stat(player, BRAKES);
    } else
    {   worm[player].deltax = deltax;
        worm[player].deltay = deltay;
}   }

SBYTE valid(SBYTE x, SBYTE y)
{   if (x >= 0 && x <= FIELDX && y >= 0 && y <= FIELDY)
        return(TRUE);
    else return(FALSE);
}

MODULE UBYTE whichcreature(SBYTE x, SBYTE y, UBYTE species, UBYTE exception)
{   UBYTE i;

    for (i = 0; i <= CREATURES; i++)
        if
        (   creature[i].alive
         && creature[i].x == x
         && creature[i].y == y
         && creature[i].species == species
         && i != exception
        )
            return i;
    return 255; /* error code */
}
MODULE SBYTE whichteleport(SBYTE x, SBYTE y)
{   SBYTE which;

    for (which = 0; which <= 3; which++)
        if (teleport[level][which].alive && teleport[level][which].x == x && teleport[level][which].y == y)
            return((SBYTE) which);
    return((SBYTE) -1); /* error code */
}

MODULE void wormbullet(SBYTE player)
{   ABOOL finished,
          ok,
          flag     = FALSE,
          lettered = FALSE;
    SBYTE distance,
          i, j,
          x, y;
    UBYTE c;

    if (!worm[player].ammo)
    {   stat(player, BONUS);
    if (worm[player].speed == FAST)
            distance = DISTANCE_FAST;
    elif (worm[player].speed == NORMAL)
           distance = DISTANCE_NORMAL;
        elif (worm[player].speed == SLOW)
           distance = DISTANCE_SLOW;
        else
        {  // assert(worm[player].speed == VERYSLOW);
           distance = DISTANCE_VERYSLOW;
        }

    /* check for metal */

    for (i = 1; i < distance; i++)
    {   x = xwrap(worm[player].x + (i * worm[player].deltax));
        y = ywrap(worm[player].y + (i * worm[player].deltay));
        if (field[x][y] == METAL)
        flag = TRUE;
    }

    if (!flag)
        {   // assert(abs(worm[player].deltax) <= 1 && abs(worm[player].deltay) <= 1);
        x = xwrap(worm[player].x + (worm[player].deltax * distance));
        y = ywrap(worm[player].y + (worm[player].deltay * distance));
            c = field[x][y];
            ok = TRUE;
            if (c == TELEPORT)
            {   ok = FALSE;
                i = whichteleport(x, y);
            if (!blocked(i, worm[player].deltax, worm[player].deltay))
            ok = TRUE;
            } elif (c >= FIRSTGLOW && c <= LASTGLOW)
            {   if (player != c - FIRSTGLOW)
                {   ok = FALSE;
            }   }
            if (ok && c != STONE && c != GOAT && c != METAL && c != OCTOPUS)
            {   effect(FXDO_JUMP);
            worm[player].deltax *= distance;
            worm[player].deltay *= distance;
    }   }   }
    else
    {   effect(FXUSE_AMMO);
        worm[player].ammo--;
        stat(player, AMMO);
        if (worm[player].sideshot)
        {   bullet[7].alive      = bullet[8].alive      = TRUE;
            bullet[7].teleported = bullet[8].teleported = 0;
            bullet[7].visible    = bullet[8].visible    = TRUE;
            bullet[7].reflected  = bullet[8].reflected  = FALSE;
            bullet[7].x          = bullet[8].x          = worm[player].x;
            bullet[7].y          = bullet[8].y          = worm[player].y;
            if (!worm[player].deltax && worm[player].deltay)
            {   bullet[7].deltax = -1;
                bullet[8].deltax = 1;
                bullet[7].deltay = bullet[8].deltay = 0;
            } elif (worm[player].deltax && !worm[player].deltay)
            {   bullet[7].deltax = bullet[8].deltax = 0;
                bullet[7].deltay = -1;
                bullet[8].deltay = 1;
            } else /* worm is diagonal */
            {   if (worm[player].deltax == worm[player].deltay)
                {   bullet[7].deltax = 1;
                    bullet[7].deltay = -1;
                } else
                {   bullet[7].deltax = -1;
                    bullet[7].deltay = -1;
                }
                bullet[8].deltax = -bullet[7].deltax;
                bullet[8].deltay = -bullet[7].deltay;
        }   }

        for (i = 0; i <= worm[player].power; i++)
        {   bullet[i].alive      = TRUE;
            bullet[i].teleported = 0;
            bullet[i].visible    = TRUE;
            bullet[i].reflected  = FALSE;
            bullet[i].deltax     = worm[player].deltax;
            bullet[i].deltay     = worm[player].deltay;
            if (i % 2 == 0)
                distance = i / 2;
            else distance = -((i + 1) / 2);
            if (worm[player].deltax == 0)
            {   bullet[i].x = worm[player].x + distance;
                bullet[i].y = worm[player].y;
            } elif (worm[player].deltay == 0)
            {   bullet[i].x = worm[player].x;
                bullet[i].y = worm[player].y + distance;
            } else
            {   switch (i)
                {
                case 0:
                    bullet[i].x = worm[player].x + worm[player].deltax;
                    bullet[i].y = worm[player].y + worm[player].deltay;
                break;
                case 1:
                    bullet[i].x = worm[player].x + worm[player].deltax;
                    bullet[i].y = worm[player].y;
                break;
                case 2:
                    bullet[i].x = worm[player].x;
                    bullet[i].y = worm[player].y + worm[player].deltay;
                break;
                case 3:
                    bullet[i].x = worm[player].x + worm[player].deltax * 2;
                    bullet[i].y = worm[player].y;
                break;
                case 4:
                    bullet[i].x = worm[player].x;
                    bullet[i].y = worm[player].y + worm[player].deltay * 2;
                break;
                case 5:
                    bullet[i].x = worm[player].x + worm[player].deltax * 2;
                    bullet[i].y = worm[player].y - worm[player].deltay;
                break;
                case 6:
                    bullet[i].x = worm[player].x - worm[player].deltax;
                    bullet[i].y = worm[player].y + worm[player].deltay * 2;
                break;
                default:
                break;
        }   }   }

        /* Bullets are now set up. */

        finished = FALSE;
        while (!finished)
        {   finished = TRUE;
            for (i = 0; i <= 8; i++)
            {   if (bullet[i].alive)
                {   if (bullet[i].visible)
                    {   if (worm[player].remnants)
                            change(bullet[i].x, bullet[i].y, FIRSTGLOW + player);
                        else change(bullet[i].x, bullet[i].y, EMPTY);
                    }

                    finished = FALSE;
                    bullet[i].visible = TRUE;
                    if (bullet[i].reflected)
                    {   bullet[i].x -= bullet[i].deltax;
                        bullet[i].y -= bullet[i].deltay;
                    } else
                    {   bullet[i].x += bullet[i].deltax;
                        bullet[i].y += bullet[i].deltay;
                    }
                    x = bullet[i].x;
                    y = bullet[i].y;
                    c = field[x][y];
                    if (!(valid(x, y)))
                        bullet[i].alive = FALSE;
                    elif (x == worm[player].x && y == worm[player].y)
                    {   /* hit by own bullet */
                        bullet[i].alive = FALSE;
                        if (worm[player].armour == 0)
                        {   worm[player].cause = FIRSTFIRE + player;
                            worm[player].victor = -1;
                            worm[player].alive = FALSE;
                    }   }
                    elif (c >= FIRSTHEAD && c <= LASTHEAD)
                    {   if (worm[c - FIRSTHEAD].armour == 0)
                        {   worm[c - FIRSTHEAD].cause = FIRSTFIRE + player;
                            worm[c - FIRSTHEAD].victor = player;
                            worm[c - FIRSTHEAD].alive = FALSE;
                        } else effect(FXUSE_ARMOUR);
                        bullet[i].alive = FALSE;
                    } elif (c >= FIRSTPROTECTOR && c <= LASTPROTECTOR)
                    {   if (player != c - FIRSTPROTECTOR)
                        {   effect(FXUSE_PROTECTOR);
                            bullet[i].alive = FALSE;
                        } else bullet[i].visible = FALSE;
                    } elif (c >= FIRSTLETTER && c <= LASTLETTER)
                    {   getnumber(player);
                        lettered = TRUE;
                    } elif (c >= FIRSTGRAVE && c <= LASTGRAVE)
                    {   bullet[i].alive = FALSE;
                    } elif (c >= FIRSTMISSILE && c <= LASTMISSILE)
                    {   if (player != c - FIRSTMISSILE)
                            creature[whichcreature(x, y, MISSILE, 255)].alive = FALSE;
                        else bullet[i].visible = FALSE;
                    } elif (c >= FIRSTDRIP && c <= LASTDRIP)
                    {   j = whichcreature(x, y, DRIP, 255);
                        creature[j].alive = FALSE;
                    } else
                    {   switch(c)
                        {
                        case BOMB:
                            // sets it off, for your benefit
                            bullet[i].alive = FALSE;
                            bombblast(HEAD, player, x, y);
                        break;
                        case SLIME:
                        case WOOD:
                            // destroys one layer of it
                            bullet[i].alive = FALSE;
                            change(x, y, EMPTY);
                        break;
                        case METAL:
                            if (bullet[i].reflected)
                                bullet[i].alive = FALSE;
                            else
                            {   bullet[i].reflected = TRUE;
                                bullet[i].x -= bullet[i].deltax * 2;
                                bullet[i].y -= bullet[i].deltay * 2;
                            }
                            break;
                        case STONE:
                            bullet[i].alive = FALSE;
                        break;
                        case TELEPORT:
                            j = whichteleport(bullet[i].x, bullet[i].y);
                            if (bullet[i].teleported == 2)
                                bullet[i].alive = FALSE;
                            else
                            {   effect(FXUSE_TELEPORT);
                                bullet[i].visible = FALSE;
                                bullet[i].teleported++;
                                bullet[i].x = teleport[level][partner(j)].x;
                                bullet[i].y = teleport[level][partner(j)].y;
                            }
                        break;
                        case CLOUD:
                        case DOG:
                        case FISH:
                        case FRAGMENT:
                        case GOAT:
                        case OCTOPUS:
                        case ORB:
                        case PENGUIN:
                        case WHIRLWIND:
                            bullet[i].alive = FALSE;
                            j = whichcreature(x, y, c, 255);
                            wormkillcreature(player, j);
                            change(x, y, EMPTY);
                        break;
                        case TIMEBOMB:
                            bullet[i].alive = FALSE;
                            creature[whichcreature(x, y, TIMEBOMB, 255)].alive = FALSE;
                            bombblast(BOMB, 0, x, y);
                            change(x, y, EMPTY);
                        break;
                        default:
                        break;
                    }   }

                    // x and y need this refreshing here
                    x = bullet[i].x;
                    y = bullet[i].y;
                    if (bullet[i].alive && bullet[i].visible)
                    {   draw(x, y, FIRSTFIRE + player);
        }   }   }   }
        if (lettered)
        {   putnumber();
        }
        clearkybd();
}   }

/* NAME     wormloop -- controls worms and protectors
SYNOPSIS    wormloop(SBYTE);
FUNCTION    Amiga-worm thinking, processing one keystroke from the
            worm's queue, all the worm's protectors' control, the
            worm's control.
MODULE      engine.c */

MODULE void wormloop(SBYTE player)
{   SBYTE bestx = 0, besty = 0, // to avoid spurious warnings
          dirx, diry, i, j, thisprot, x, y, index1, index2;
    SWORD bestgood, good;
    UBYTE c;

   /*  Amiga worm control
       Remove a keystroke from the worm queue
       Move worm (and add a keystroke to the dog queue)
       Check for enclosure
       Move protectors
       Collision detection

    AI: Amiga worm control.

    Worm checks ahead, left and right one square. Assigns opinions
    to those three choices and then takes the appropriate one.

    Things which slow the worm down are doubly feared; this is to avoid
    endless ramming situations. */

    if (worm[player].control == AMIGA)
    {   if (!arand(50))
            wormqueue(player, arand(2) - 1, arand(2) - 1);
        else
        {   bestgood = -128;

            for (i = 0; i <= 2; i++)
            {   switch(i)
                {
                case 0:
                    dirx = worm[player].deltax;
                    diry = worm[player].deltay;
                break;
                case 1:
                    if (worm[player].deltax == 0) /* if going north or south */
                    {   dirx = -1;                /* then look west */
                        diry = 0;
                    } else                        /* if going east or west */
                    {   dirx = 0;                 /* then look north */
                        diry = -1;
                    }
                break;
                case 2:
                    if (worm[player].deltax == 0) /* if going north or south */
                    {   dirx = 1;                 /* then look east */
                        diry = 0;
                    } else                        /* if going east or west */
                    {   dirx = 0;                 /* then look south */
                        diry = 1;
                    }
                break;
                default:
                    dirx = diry = 0; // to prevent spurious warnings
                break;
                }
                c = field[xwrap(worm[player].x + dirx)][ywrap(worm[player].y + diry)];
                if (c >= FIRSTLETTER && c <= LASTLETTER)
                    good = POINTS_LETTER;
                elif (c >= FIRSTHEAD && c <= LASTHEAD)
                    good = -(PAIN_HEAD);
                elif (c <= LASTOBJECT)
                    good = (SWORD) object[c].score;
                elif (c == FIRSTPROTECTOR + player)
                    good = POINTS_EMPTY;
                elif (c >= FIRSTGLOW && c <= LASTGLOW)
                {   if (player == c - FIRSTGLOW)
                good = -1;
                    else good = -(PAIN_GLOW);
                } elif (c >= FIRSTMISSILE && c <= LASTMISSILE)
                {   if (player == c - FIRSTMISSILE)
                        good = 0;
                    else good = -(PAIN_MISSILE);
                } elif (c >= FIRSTDRIP && c <= LASTDRIP)
                {   if (player == c - FIRSTDRIP)
                        good = SCORE_DRIP;
                    else good = -(PAIN_DRIP);
                } elif (c >= FIRSTGRAVE && c <= LASTGRAVE)
                {   good = POINTS_GRAVE;
                } elif (c >= FIRSTTAIL && c <= LASTTAIL)
                {   if (worm[player].armour > 10)
                        if (player != c - FIRSTTAIL)
                            good = POINTS_TURNSILVER;
                        else good = 0;
                    elif (player == c - FIRSTTAIL)
                        good = -(PAIN_FRIENDLYTAIL);
                    else good = -(PAIN_ENEMYTAIL);
                } else switch(c)
                {
                case GOLD:
                    good = POINTS_GOLD;
                break;
                case SILVER:
                    good = POINTS_SILVER;
                break;
                case EMPTY:
                    good = POINTS_EMPTY;
                break;
                case SLIME:
                    if (worm[player].armour > 0)
                        good = 0;
                    else good = -(PAIN_SLIME);
                break;
                case WOOD:
                    if (worm[player].armour > 0)
                        good = 0;
                    else good = -(PAIN_WOOD);
                break;
                case STONE:
                    good = -(PAIN_STONE * 2);
                break;
                case METAL:
                    good = -(PAIN_METAL * 2);
                break;
                case GOAT:
                    good = -(PAIN_GOAT * 2);
                break;
                case CLOUD:
                    good = -(PAIN_CLOUD);
                break;
                case DOG:
                    good = -(PAIN_DOG);
                break;
                case FISH:
                    good = -(PAIN_FISH);
                break;
                case FRAGMENT:
                    good = -(PAIN_FRAGMENT);
                break;
                case GIRAFFE:
                    good = -(PAIN_GIRAFFE);
                break;
                case LION:
                    good = -(PAIN_LION);
                break;
                case OCTOPUS:
                    good = -(PAIN_OCTOPUS * 2);
                break;
                case ORB:
                    good = -(PAIN_ORB);
                break;
                case WHIRLWIND:
                    good = -(PAIN_WHIRLWIND);
                break;
                default:
                    good = 0;
                break;
                }
                if (good > bestgood)
                {   bestx = dirx;
                    besty = diry;
                    bestgood = good;
            }   }
            if (bestgood < -2 && !arand(1))
            {   // turn in any of the 8 directions, or fire
                wormqueue
                (   player,
                    (SBYTE) ((arand(1) * 2) - 1),
                    (SBYTE) ((arand(1) * 2) - 1)
                );
            }
            elif (bestgood < -1 && !arand(1))
                wormqueue(player, 0, 0);
            elif (bestgood < 0 && !arand(5))
                wormqueue(player, 0, 0);
            elif (bestx != worm[player].deltax || besty != worm[player].deltay)
                wormqueue(player, bestx, besty);
    }   }

    /* remove a keystroke from the worm queue */

    if (worm[player].pos != -1)
    {   if (first && worm[2].lives && worm[2].control == JOYSTICK)
        {   first = FALSE;
            /* Yes, this is defensive programming :-(
            Because the first time the blue worm has joystick control, a
            bizarre firebutton event seems to occur. */
        } else
        {   if (thewormqueue[player][0].deltax == 0 && thewormqueue[player][0].deltay == 0)
                wormbullet(player);
            else
            {   if (!worm[player].frosted)
                {   turnworm(player, thewormqueue[player][0].deltax, thewormqueue[player][0].deltay);
        }   }   }
        if (--worm[player].pos != -1)
        {   for (i = 0; i <= worm[player].pos; i++)
            {   thewormqueue[player][i].deltax = thewormqueue[player][i + 1].deltax;
                thewormqueue[player][i].deltay = thewormqueue[player][i + 1].deltay;
    }   }   }
    worm[player].frosted = FALSE;

    /* move worm */

    if (worm[player].last == FIRSTTAIL + player)
    {   field[worm[player].x][worm[player].y] = FIRSTTAIL + player;
        if (!thick)
        {   index1 =       worm[player].olddeltax + 1 + (      (worm[player].olddeltay + 1) * 3);
            index2 = bsign(worm[player].deltax)   + 1 + ((bsign(worm[player].deltay)   + 1) * 3);
            drawtail(worm[player].x, worm[player].y, eachtail[player][0][index1][index2]);
        } else
        {   draw(worm[player].x, worm[player].y, FIRSTTAIL + player);
    }   }
    elif (worm[player].last == FIRSTGLOW + player)
    {   field[worm[player].x][worm[player].y] = FIRSTGLOW + player;
        if (!thick)
        {   index1 =       worm[player].olddeltax + 1 + (      (worm[player].olddeltay + 1) * 3);
            index2 = bsign(worm[player].deltax)   + 1 + ((bsign(worm[player].deltay)   + 1) * 3);
            drawtail(worm[player].x, worm[player].y, eachtail[player][1][index1][index2]);
        } else
        {   draw(worm[player].x, worm[player].y, FIRSTGLOW + player);
    }   }
    else
    {   change(worm[player].x, worm[player].y, worm[player].last);
    }

    worm[player].x = xwrap(worm[player].x + worm[player].deltax);
    worm[player].y = ywrap(worm[player].y + worm[player].deltay);

    if (worm[player].glow)
    {   worm[player].last = FIRSTGLOW + player;
    } else
    {   worm[player].last = FIRSTTAIL + player;
    }

    for (i = 0; i <= CREATURES; i++)
    {   if (creature[i].alive && creature[i].species == DOG && creature[i].dormant > DORMANT && creature[i].type == player)
        {   if (!worm[player].rammed)
                dogqueue(i, worm[player].deltax, worm[player].deltay);
            if (creature[i].dormant < CHASING)
            {   creature[i].dormant++;
                draw(creature[i].x, creature[i].y, DOGAWAKENING);
    }   }   }

    /* The deltas are not changed back to the range of -1..1 until after
    the dogs have looked at the queue. This enables them to jump properly. */

    worm[player].rammed = FALSE;
    worm[player].deltax = bsign(worm[player].deltax);
    worm[player].deltay = bsign(worm[player].deltay);
    worm[player].olddeltax = worm[player].deltax;
    worm[player].olddeltay = worm[player].deltay;

    /*  check for enclosure
        #####
        #...#
        #...# . = interior
        #...# # = tail
        ####! ! = head */

    enclosed = FALSE;
    for (i = 2; i <= 10; i++) // for each size of interior
    {   for (j = 0; j <= 3; j++) // four times, once for each direction
        {   checkrectangle(j, player, i, i);
            if (worm[player].encloser)
            {   checkrectangle(j, player, i, i + 1);
                checkrectangle(j, player, i + 1, i);
    }   }   }

    // move protectors

    for (i = 0; i <= PROTECTORS; i++)
    {   if (protector[player][i].alive)
        {   if (protector[player][i].visible)
            {   change(protector[player][i].x, protector[player][i].y, protector[player][i].last);
            } else protector[player][i].visible = TRUE;
            protector[player][i].last = EMPTY;
            if (i == NOSE)
            {   protector[player][i].relx = worm[player].deltax * DISTANCE_NOSE;
                protector[player][i].rely = worm[player].deltay * DISTANCE_NOSE;
                if (!worm[player].affixer)
                {   if (worm[player].position == -1)
                        worm[player].posidir = 1;
                    elif (worm[player].position == 1)
                        worm[player].posidir = -1;
                    worm[player].position += worm[player].posidir;
                    if (worm[player].deltax == 0)
                        protector[player][i].relx = worm[player].position;
                    elif (worm[player].deltay == 0)
                        protector[player][i].rely = worm[player].position;
                    elif (worm[player].position == -1)
                        protector[player][i].relx = worm[player].deltax * (DISTANCE_NOSE - 1);
                    elif (worm[player].position == 1)
                        protector[player][i].rely = worm[player].deltay * (DISTANCE_NOSE - 1);
            }   }
            elif (!worm[player].affixer)
            {   if (protector[player][i].relx == 1 && protector[player][i].rely == -1)
                {   protector[player][i].deltax = 0;
                    protector[player][i].deltay = 1;
                } elif (protector[player][i].relx == 1 && protector[player][i].rely == 1)
                {   protector[player][i].deltax = -1;
                    protector[player][i].deltay = 0;
                } elif (protector[player][i].relx == -1 && protector[player][i].rely == 1)
                {   protector[player][i].deltax = 0;
                    protector[player][i].deltay = -1;
                } elif (protector[player][i].relx == -1 && protector[player][i].rely == -1)
                {   protector[player][i].deltax = 1;
                    protector[player][i].deltay = 0;
                }
                protector[player][i].relx += protector[player][i].deltax;
                protector[player][i].rely += protector[player][i].deltay;
            }
            protector[player][i].x = worm[player].x + protector[player][i].relx;
            protector[player][i].y = worm[player].y + protector[player][i].rely;
            if (!valid(protector[player][i].x, protector[player][i].y))
            {   protector[player][i].visible = FALSE;
    }   }   }

    // head collision detection
    wormcol(player, worm[player].x, worm[player].y);
    // draw head
    field[worm[player].x][worm[player].y] = FIRSTHEAD + player;
    drawhead(player, worm[player].x, worm[player].y);

    updatearrow(worm[player].arrowy);
    worm[player].arrowy = worm[player].y;
    updatearrow(worm[player].arrowy);

    // protector collision detection
    for (thisprot = 0; thisprot <= PROTECTORS; thisprot++)
    {   if (protector[player][thisprot].alive && protector[player][thisprot].visible)
        {   protcol(player, protector[player][thisprot].x, protector[player][thisprot].y, thisprot);
            // draw protector
            if (protector[player][thisprot].alive && protector[player][thisprot].visible) // in case protector has just been killed, etc.
            {   change(protector[player][thisprot].x, protector[player][thisprot].y, FIRSTPROTECTOR + player);
    }   }   }

    if (worm[player].cutter)
    {   // straight ahead
        x = xwrap(worm[player].x + worm[player].deltax);
        y = ywrap(worm[player].y + worm[player].deltay);
        squareblast(HEAD, player, field[x][y], x, y, TRUE);
        // left
        if (!worm[player].deltax || !worm[player].deltay)
        {   // if orthagonal
            x = xwrap(worm[player].x + worm[player].deltay);
            y = ywrap(worm[player].y - worm[player].deltax);
        } else // diagonal
        {   if (worm[player].deltax == worm[player].deltay)
            {   x = xwrap(worm[player].x + worm[player].deltax);
                y = ywrap(worm[player].y - worm[player].deltay);
            } else
            {   x = xwrap(worm[player].x - worm[player].deltax);
                y = ywrap(worm[player].y + worm[player].deltay);
        }   }
        squareblast(HEAD, player, field[x][y], x, y, TRUE);
        // right
        if (!worm[player].deltax || !worm[player].deltay)
        {   // if orthagonal
            x = xwrap(worm[player].x - worm[player].deltay);
            y = ywrap(worm[player].y + worm[player].deltax);
        } else // diagonal
        {   if (worm[player].deltax == worm[player].deltay)
            {   x = xwrap(worm[player].x - worm[player].deltax);
                y = ywrap(worm[player].y + worm[player].deltay);
            } else
            {   x = xwrap(worm[player].x + worm[player].deltax);
                y = ywrap(worm[player].y - worm[player].deltay);
        }   }
        squareblast(HEAD, player, field[x][y], x, y, TRUE);
        // ahead left
        if (!worm[player].deltax || !worm[player].deltay)
        {   // if orthagonal
            if (worm[player].deltax) // if east or west
            {   x = xwrap(worm[player].x + worm[player].deltax);
                y = ywrap(worm[player].y - worm[player].deltax);
            } else // north or south
            {   x = xwrap(worm[player].x + worm[player].deltay);
                y = ywrap(worm[player].y + worm[player].deltay);
        }   }
        else // diagonal
        {   if (worm[player].deltax == worm[player].deltay)
            {   x = xwrap(worm[player].x + worm[player].deltax);
                y = worm[player].y;
            } else
            {   x = worm[player].x;
                y = ywrap(worm[player].y + worm[player].deltay);
        }   }
        squareblast(HEAD, player, field[x][y], x, y, TRUE);
        // ahead right
        if (!worm[player].deltax || !worm[player].deltay)
        {   // if orthagonal
            if (worm[player].deltax) // if east or west
            {   x = xwrap(worm[player].x + worm[player].deltax);;
                y = ywrap(worm[player].y + worm[player].deltax);
            } else // north or south
            {   x = xwrap(worm[player].x - worm[player].deltay);
                y = ywrap(worm[player].y + worm[player].deltay);
        }   }
        else // diagonal
        {   if (worm[player].deltax == worm[player].deltay)
            {   x = worm[player].x;
                y = ywrap(worm[player].y + worm[player].deltay);
            } else
            {   x = xwrap(worm[player].x + worm[player].deltax);
                y = worm[player].y;
        }   }
        squareblast(HEAD, player, field[x][y], x, y, TRUE);
}   }

MODULE void protcol(SBYTE player, SBYTE x, SBYTE y, SBYTE thisprot)
{   UBYTE c = field[x][y];
    SBYTE i;

    if (c >= FIRSTHEAD && c <= LASTHEAD)
    {   protworm(x, y, player, c - FIRSTHEAD);
    } elif (c >= FIRSTPROTECTOR && c <= LASTPROTECTOR)
    {   protprot(x, y, player, c - FIRSTPROTECTOR);
    } elif (c >= FIRSTTAIL && c <= LASTTAIL)
    {   if (player == c - FIRSTTAIL)
        {   protector[player][thisprot].visible = FALSE;
    }   }
    elif
    (   c == STONE
     || c == WOOD
     || c == METAL
     || c == TIMEBOMB
     || c == TELEPORT
     || c == FIRSTGLOW + player
    )
    {   protector[player][thisprot].visible = FALSE;
    } elif (c >= FIRSTMISSILE && c <= LASTMISSILE)
    {   i = whichcreature(x, y, MISSILE, 255);
        protcreature(player, i);
    } elif (c >= FIRSTDRIP && c <= LASTDRIP)
    {   i = whichcreature(x, y, DRIP, 255);
        protcreature(player, i);
    } elif
    (   c == BIRD
     || c == CLOUD
     || c == DOG
     || c == FRAGMENT
     || c == ORB
     || c == PENGUIN
     || c == WHIRLWIND
    )
    {   i = whichcreature(x, y, c, 255);
        protcreature(player, i);
    } else
    {   bothcol(player, x, y);
}   }

MODULE void bothcol(SBYTE player, SBYTE x, SBYTE y)
{   UBYTE c = field[x][y];

    if (c >= FIRSTLETTER && c <= LASTLETTER)
    {   if (!(getnumber(player)))
        {   putnumber();
    }   }
    elif (c <= LASTOBJECT)
    {   wormscore(player, wormobject(player, x, y));
    } elif (c >= FIRSTGRAVE && c <= LASTGRAVE)
    {   effect(FXGET_SKULL);
        wormscore(player, POINTS_GRAVE);
        worm[player].bias += worm[c - FIRSTGRAVE].bias;

                if (worm[player].bias > 0)
                {   if (worm[player].bias > BIASLIMIT)
                        worm[player].bias = BIASLIMIT;
                    stat(player, BIAS);
                    worm[c - FIRSTGRAVE].bias = 0;
                    stat(c - FIRSTGRAVE, BIAS);
                }
                worm[player].multi *= worm[c - FIRSTGRAVE].multi;
                if (worm[player].multi > 1)
                {   if (worm[player].multi > MULTILIMIT)
                        worm[player].multi = MULTILIMIT;
                }
                worm[player].power += worm[c - FIRSTGRAVE].power;
                if (worm[player].power > 1)
                {   if (worm[player].power > POWERLIMIT)
                        worm[player].power = POWERLIMIT;
                    stat(player, POWER);
                    worm[c - FIRSTGRAVE].power = 0;
                    stat(c - FIRSTGRAVE, POWER);
                }
                worm[player].ammo += worm[c - FIRSTGRAVE].ammo;
                if (worm[player].ammo > 0)
                {   if (worm[player].ammo > AMMOLIMIT)
                        worm[player].ammo = AMMOLIMIT;
                    stat(player, AMMO);
                    worm[c - FIRSTGRAVE].ammo = 0;
                    stat(c - FIRSTGRAVE, AMMO);
                }
                worm[player].armour += worm[c - FIRSTGRAVE].armour;
                if (worm[player].armour > 0)
                {   if (worm[player].armour > ARMOURLIMIT)
                        worm[player].armour = ARMOURLIMIT;
                    stat(player, ARMOUR);
                    worm[c - FIRSTGRAVE].armour = 0;
                    stat(c - FIRSTGRAVE, ARMOUR);
                }
                if (worm[c - FIRSTGRAVE].brakes)
                {   worm[player].brakes = TRUE;
                    stat(player, BRAKES);
                    worm[c - FIRSTGRAVE].brakes = FALSE;
                    worm[c - FIRSTGRAVE].speed = NORMAL;
                    stat(c - FIRSTGRAVE, BRAKES);
                }
                if (worm[c - FIRSTGRAVE].affixer)
                {   worm[player].affixer = TRUE;
                    icon(player, AFFIXER);
                    worm[c - FIRSTGRAVE].affixer = FALSE;
                    icon(c - FIRSTGRAVE, AFFIXER);
                }
                if (worm[c - FIRSTGRAVE].remnants)
                {   worm[player].remnants = TRUE;
                    icon(player, REMNANTS);
                    worm[c - FIRSTGRAVE].remnants = FALSE;
                    icon(c - FIRSTGRAVE, REMNANTS);
                }
                if (worm[c - FIRSTGRAVE].sideshot)
                {   worm[player].sideshot = TRUE;
                    icon(player, SIDESHOT);
                    worm[c - FIRSTGRAVE].sideshot = FALSE;
                    icon(c - FIRSTGRAVE, SIDESHOT);
                }
                if (worm[c - FIRSTGRAVE].pusher)
                {   worm[player].pusher = TRUE;
                    icon(player, PUSHER);
                    worm[c - FIRSTGRAVE].pusher = FALSE;
                    icon(c - FIRSTGRAVE, PUSHER);
                }
                if (worm[c - FIRSTGRAVE].encloser)
                {   worm[player].encloser = TRUE;
                    icon(player, ENCLOSER);
                    worm[c - FIRSTGRAVE].encloser = FALSE;
                    icon(c - FIRSTGRAVE, ENCLOSER);
                }
                if (worm[c - FIRSTGRAVE].cutter)
                {   worm[player].cutter += worm[c - FIRSTGRAVE].cutter;
                    icon(player, CUTTER);
                    worm[c - FIRSTGRAVE].cutter = 0;
                    icon(c - FIRSTGRAVE, CUTTER);
                }

    } else
    {   switch(c)
        {
        case EMPTY:
            wormscore(player, POINTS_EMPTY);
        break;
        case SILVER:
            wormscore(player, POINTS_SILVER);
        break;
        case GOLD:
            wormscore(player, POINTS_GOLD);
        break;
        case DYNAMITE:
            effect(FXUSE_BOMB);
            banging = TRUE;
            bangdynamite(x, y, player);
            wormscore(player, worm[player].dynamitescore);
            worm[player].dynamitescore = 0;
        break;
        default:
        break;
}   }   }

AGLOBAL void wormscore(SBYTE player, ULONG score)
{   worm[player].score += score * worm[player].multi * players;
    stat(player, BONUS);
}

SBYTE xwrap(SBYTE x)
{    if (x < 0)
        x += FIELDX + 1;
    elif (x > FIELDX)
        x -= FIELDX + 1;
    return(x);
}
SBYTE ywrap(SBYTE y)
{    if (y < 0)
        y += FIELDY + 1;
    elif (y > FIELDY)
        y -= FIELDY + 1;
    return(y);
}

MODULE void ramming(SBYTE player)
{   SBYTE i;

    worm[player].rammed = TRUE;
    worm[player].x = xwrap(worm[player].x - worm[player].deltax);
    worm[player].y = ywrap(worm[player].y - worm[player].deltay);
    for (i = 0; i <= PROTECTORS; i++)
    {   /* no point checking whether the protectors are alive or dead */
        protector[player][i].x -= worm[player].deltax;
        protector[player][i].y -= worm[player].deltay;
}   }

MODULE SWORD atleast(SWORD value, SWORD minimum)
{   if (value < minimum)
        return(minimum);
    else return(value);
}

MODULE void __inline change(SBYTE x, SBYTE y, UBYTE image)
{   // assert(valid(x, y));
    field[x][y] = image;
    draw(x, y, image);
}

/* WormWars FSET format for fieldset contents and high score table (Amiga
and IBM-PC), as follows:

header
        TEXT[]                          "FSET x.x" (NULL-terminated)
    SBYTE                levels;
high score table
    for (slot = 0; slot <= HISCORES; slot++)
    {    SBYTE            hiscore[slot].player,
                    hiscore[slot].level;
        SLONG            hiscore[slot].score;
        TEXT[]            hiscore[slot].name (NULL-terminated)
        TEXT[]            hiscore[slot].time (NULL-terminated)
        TEXT[]            hiscore[slot].date (NULL-terminated)
    }
level data
    for (level = 0; level <= levels; level++)
    {    SBYTE            startx[level],
                                        starty[level];
        ABOOL            teleport[level][0].alive;
        SBYTE            teleport[level][0].x,
                                        teleport[level][0].y;
        ABOOL            teleport[level][1].alive;
        SBYTE            teleport[level][1].x,
                                        teleport[level][1].y;
        for (x = 0; x <= FIELDX; x++)
            for (y = 0; y <= FIELDY; y++)
                SBYTE    board[level][x][y];
    }
version string
        TEXT[]                          "$VER: Worm Wars x.x (dd.mm.yy) $" (NULL-terminated) */

MODULE SBYTE onlyworm(ABOOL alive)
{   SBYTE i,
          theworm = -1, // to prevent spurious warnings
          worms   = 0;

    for (i = 0; i <= 3; i++)
        if (worm[i].control != NONE && ((!alive) || worm[i].lives))
        {   theworm = i;
            worms++;
        }
    if (worms == 1)
        return (SBYTE) theworm;
    else return -1;
}

MODULE void wormkillcreature(UBYTE player, UBYTE which)
{   /* This is defensive programming. Sometimes squareblast() finds an
       orb on the field for which there is no corresponding creature
       (ie. an 'orphan orb'. whichcreature() on such a square will
       return 255. */

    if (which != 255)
    {   wormscore(player, creature[which].score);
        creature[which].alive = FALSE;
        if (worm[player].bias)
        {   worm[player].lives++;
            stat(player, LIFE);
        }
        if (creature[which].species == FRAGMENT)
        {   effect(FXDEATH_FRAGMENT);
        } elif (creature[which].species == DRIP)
        {   effect(FXGET_DRIP);
}   }   }

MODULE void wormworm(SBYTE x, SBYTE y, UBYTE which1, UBYTE which2)
{   if (worm[which1].armour == 0 && worm[which2].armour == 0)
    {   /* both worms die */
        worm[which1].cause  = FIRSTHEAD + which2;
        worm[which1].alive  = FALSE;
        worm[which1].victor = -1;
        worm[which2].cause  = FIRSTHEAD + which1;
        worm[which2].alive  = FALSE;
        worm[which2].victor = -1;
    } elif (worm[which1].armour > 0 && worm[which2].armour == 0)
    {   /* 1st worm lives, 2nd worm dies  */
        worm[which2].cause  = FIRSTHEAD + which1;
        worm[which2].alive  = FALSE;
        worm[which2].victor = which1;
    } elif (worm[which1].armour == 0 && worm[which2].armour > 0)
    {   /* 1st worm dies, 2nd worm lives */
        worm[which1].cause  = FIRSTHEAD + which2;
        worm[which1].alive  = FALSE;
        worm[which1].victor = which2;
}   }
MODULE void protworm(SBYTE x, SBYTE y, UBYTE which1, UBYTE which2)
{   SBYTE i, j = -1; // to prevent spurious warnings

    for (i = 0; i <= PROTECTORS; i++)
         if (protector[which1][i].alive && protector[which1][i].x == x && protector[which1][i].y == y)
         {    j = i;
              break;
         }

    if (which1 != which2)
    {   if (worm[which2].armour == 0)
        {   effect(FXUSE_PROTECTOR);
            worm[which2].cause  = FIRSTPROTECTOR + which1;
            worm[which2].victor = which1;
            worm[which2].alive  = FALSE;
        } else
        {   effect(FXUSE_ARMOUR);
            protector[which1][j].visible = FALSE;
    }   }
    else
    {   /* protector is over worm's own head; caused by ramming */
        protector[which1][j].visible = FALSE;
}   }
MODULE void protprot(SBYTE x, SBYTE y, UBYTE which1, UBYTE which2)
{   SBYTE i, p1 = -1, p2 = -1; // to prevent spurious warnings

    /* Find both protectors */

    for (i = 0; i <= PROTECTORS; i++)
    {   if (protector[which1][i].alive && protector[which1][i].x == x && protector[which1][i].y == y)
            p1 = i;
        if (protector[which2][i].alive && protector[which2][i].x == x && protector[which2][i].y == y)
            p2 = i;
    }
    protector[which1][p1].alive = FALSE;
    protector[which2][p2].alive = FALSE;
    change(x, y, EMPTY);
}

MODULE ULONG wormobject(UBYTE player, SBYTE x, SBYTE y)
{   AUTO    UBYTE c = field[x][y], d;
    AUTO    ULONG score = object[c].score;
    AUTO    UBYTE i, j, generated = 0;
    AUTO    SBYTE xx, xxx, yy, yyy;
    AUTO    ABOOL done;
    PERSIST UBYTE otherfield[FIELDX + 1][FIELDY + 1];

    for (i = 0; i <= MAGNETS; i++)
        if (magnet[i].alive && x == magnet[i].x && y == magnet[i].y)
             magnet[i].alive = FALSE;

    if (!valid(x, y)) // defensive programming
    {   return 0;

        /* AUTO TEXT temp1[SAYLIMIT + 1], temp2[8];

        strcpy(temp1, "BAD OBJECT AT x: ");
        stci_d(temp2, x);
        strcat(temp1, temp2);
        strcat(temp1, ", y: ");
        stci_d(temp2, y);
        strcat(temp1, temp2);
        strcat(temp1, "!");
        say(temp1, worm[player].colour);
        draw(FIELDX + 1, 0, c); // indicates which object
        Delay(250);
        clearkybd();
        anykey(FALSE); */
    }

    switch(c)
    {
    case BONUS:
        getnumber(player);
        change(numberx, numbery, FIRSTLETTER + number - 1);
        updatearrow(numbery);
    break;
    case AMMO:
        effect(FXGET_AMMO);
        worm[player].ammo += arand(4) + 2; /* 2-6 bullets */
        stat(player, AMMO);
    break;
    case ARMOUR:
        effect(FXGET_OBJECT);
        worm[player].armour += ADD_ARMOUR + arand(RAND_ARMOUR);
        stat(player, ARMOUR);
    break;
    case BRAKES:
        effect(FXGET_OBJECT);
        worm[player].brakes = TRUE;
        stat(player, BRAKES);
    break;
    case BOMB:
        if (worm[player].glow == 0)
            draw(worm[player].x, worm[player].y, eachworm[player][0][worm[player].deltax + 1 + (worm[player].deltay + 1) * 3]);
        else draw(worm[player].x, worm[player].y, eachworm[player][1][worm[player].deltax + 1 + (worm[player].deltay + 1) * 3]);
        bombblast(HEAD, player, worm[player].x, worm[player].y);
    break;
    case POWER:
        effect(FXGET_POWERUP);
        if (worm[player].power < POWERLIMIT)
        {   worm[player].power += 2;
            stat(player, POWER);
        }
    break;
    case SLAYER:
        for (i = 0; i <= CREATURES; i++)
        {   if (creature[i].alive)
            {   if
                (   (   creature[i].species != MISSILE
                     && creature[i].species != DRIP
                    )
                 || creature[i].type != player
                )
                {   wormkillcreature(player, i);
                    change(creature[i].x, creature[i].y, EMPTY);
        }   }   }
        for (i = 0; i <= 3; i++)
        {   if (player != i && worm[i].armour == 0)
            {   worm[i].alive = FALSE;
                worm[i].cause = SLAYER;
                worm[i].victor = player;
        }   }
        for (x = 0; x <= FIELDX; x++)
            for (y = 0; y <= FIELDY; y++)
                if (field[x][y] == SLIME)
                    change(x, y, EMPTY);
    break;
    case PROTECTOR:
        // create protector
        done = FALSE;
        for (i = 0; i <= PROTECTORS; i++)
        {   if (!protector[player][i].alive && !done)
            {   do
                {   protector[player][i].relx = (arand(1) * 2) - 1;
                    protector[player][i].rely = (arand(1) * 2) - 1;
                    for (j = 0; j <= PROTECTORS; j++)
                    {   if
                        (   i == NOSE
                         || !protector[player][j].alive
                         ||  protector[player][j].x != xwrap(worm[player].x + protector[player][i].relx)
                         ||  protector[player][j].y != ywrap(worm[player].y + protector[player][i].rely)
                        ) // if we can find an area without a preexisting protector
                        {   effect(FXBORN_PROTECTOR);
                            done = TRUE;
                            protector[player][i].alive = TRUE;
                            protector[player][i].visible = FALSE;
                            protector[player][i].last = EMPTY;
                            if (i == NOSE)
                            {   worm[player].position = -1;
                }   }   }   }
                while (!done);
        }   }
    break;
    case MISSILE:
        for (i = 0; i <= CREATURES; i++)
        {   if (!creature[i].alive)
            {   createcreature(MISSILE, i, worm[player].x, worm[player].y, 0, 0, player);
                break;
        }   }
    break;
    case LIFE:
        effect(FXGET_OBJECT);
        worm[player].lives += arand(4) + 2; /* 2-6 lives */
        stat(player, LIFE);
    break;
    case MULTIPLIER:
        effect(FXGET_OBJECT);
        if (worm[player].multi < MULTILIMIT)
            worm[player].multi *= 2;
    break;
    case BIAS:
        effect(FXGET_OBJECT);
        worm[player].bias += ADD_ARMOUR + arand(RAND_ARMOUR);
        stat(player, BIAS);
    break;
    case ICE:
        effect(FXGET_OBJECT);
        ice += ADD_ICE + arand(RAND_ICE);
    break;
    case GROWER:
        effect(FXGET_GROWER);

        /* grow dynamite */
        for (x = 0; x <= FIELDX; x++)
            for (y = 0; y <= FIELDY; y++)
                if (field[x][y] == DYNAMITE)
                    for (xx = x - 1; xx <= x + 1; xx++)
                        for (yy = y - 1; yy <= y + 1; yy++)
                            if (valid(xx, yy))
                                if (field[xx][yy] == EMPTY)
                                    field[xx][yy] = TEMPDYNAMITE;
        /* grow silver */
        for (x = 0; x <= FIELDX; x++)
            for (y = 0; y <= FIELDY; y++)
                if (field[x][y] == SILVER)
                    for (xx = x - 1; xx <= x + 1; xx++)
                        for (yy = y - 1; yy <= y + 1; yy++)
                            if (valid(xx, yy))
                                if (field[xx][yy] == EMPTY || field[xx][yy] == TEMPDYNAMITE)
                                    field[xx][yy] = TEMPSILVER;
        /* grow gold */
        for (x = 0; x <= FIELDX; x++)
            for (y = 0; y <= FIELDY; y++)
                if (field[x][y] == GOLD)
                    for (xx = x - 1; xx <= x + 1; xx++)
                        for (yy = y - 1; yy <= y + 1; yy++)
                            if (valid(xx, yy))
                                if (field[xx][yy] == EMPTY || field[xx][yy] == TEMPDYNAMITE || field[xx][yy] == TEMPSILVER)
                                    field[xx][yy] = TEMPGOLD;
        /* update field */
        for (x = 0; x <= FIELDX; x++)
            for (y = 0; y <= FIELDY; y++)
                switch (field[x][y])
                {
                case TEMPGOLD:
                    change(x, y, GOLD);
                break;
                case TEMPSILVER:
                    change(x, y, SILVER);
                break;
                case TEMPDYNAMITE:
                    change(x, y, DYNAMITE);
                break;
                default:
                break;
                }
    break;
    case TREASURE:
        treasurer = player;
        if (level)
        {   secondsperlevel = 0;
            leveltype = arand(2);
            if (leveltype == 0)
            {   say("Bonus Level: Treasury!", worm[treasurer].colour);
                leveltype = TREASURE;
            } elif (leveltype == 1)
            {   say("Bonus Level: Drips!", worm[treasurer].colour);
                leveltype = DRIP;
            } else
            {   // assert(leveltype == 2);
                say("Bonus Level: Penguins!", worm[treasurer].colour);
                leveltype = PENGUIN;
        }   }
        secondsperlevel += ADD_TREASURE + arand(RAND_TREASURE);
        if (level && leveltype != TREASURE)
            secondsperlevel *= 2;
        if (secondsperlevel > TIMELIMIT)
            secondsperlevel = TIMELIMIT;
        if (level)
        {   stat(player, BONUS);
            reallevel = level;
            level = 0;
            newlevel(player);
        }
    break;
    case AFFIXER:
        effect(FXGET_OBJECT);
        worm[player].affixer = TRUE;
        icon(player, AFFIXER);
    break;
    case SWITCHER:
        effect(FXGET_OBJECT);
        for (x = 0; x <= FIELDX; x++)
        {   for (y = 0; y <= FIELDY; y++)
            {   if (field[x][y] >= FIRSTTAIL && field[x][y] <= LASTTAIL)
                {   if (field[x][y] == FIRSTTAIL + player)
                    {   change(x, y, FIRSTGLOW + player);
                    } else
                    {   change(x, y, FIRSTTAIL + player);
                }   }
                elif (worm[player].bias)
                {   if (field[x][y] >= FIRSTGLOW && field[x][y] <= LASTGLOW && field[x][y] != FIRSTGLOW + player)
                        change(x, y, FIRSTGLOW + player);
                    elif (field[x][y] == SLIME)
                        change(x, y, DYNAMITE);
        }   }   }
    break;
    case HEALER:
        effect(FXGET_OBJECT);
        if (worm[player].lives < 100)
            worm[player].lives = 100;
        else worm[player].lives = LIVESLIMIT;
        stat(player, LIFE);
    break;
    case UMBRELLA:
        level += arand(1) + 1;
        if (level >= levels)
            level = levels; // fixed?
        endoflevel();
    break;
    case CLOCK:
        effect(FXGET_OBJECT);
        secondsperlevel += ADD_CLOCK + arand(RAND_CLOCK);
        if (secondsperlevel > TIMELIMIT)
        {   secondsperlevel = TIMELIMIT;
        }
    break;
    case SLOWER:
        effect(FXGET_OBJECT);
        for (i = 0; i <= CREATURES; i++)
            if (creature[i].alive && creature[i].species != MISSILE)
                creature[i].speed = (SBYTE) atleast(creature[i].speed * 2, VERYFAST);
    break;
    case PULSE:
        effect(FXGET_PULSE);
        for (i = 0; i <= CREATURES; i++)
        {   if (!creature[i].alive && generated <= 7)
            {   switch (generated)
                {
                case 0:
                    xx = 0;
                    yy = -1;
                break;
                case 1:
                    xx = 1;
                    yy = -1;
                break;
                case 2:
                    xx = 1;
                    yy = 0;
                break;
                case 3:
                    xx = 1;
                    yy = 1;
                break;
                case 4:
                    xx = 0;
                    yy = 1;
                break;
                case 5:
                    xx = -1;
                    yy = 1;
                break;
                case 6:
                    xx = -1;
                    yy = 0;
                break;
                case 7:
                    xx = -1;
                    yy = -1;
                break;
                default:
                break;
                }

                generated++;
                if (valid(x + xx, y + yy) && (xx != worm[player].deltax || yy != worm[player].deltay))
                {   d = field[x + xx][y + yy];
                    if ((d >= FIRSTEMPTY && d <= LASTEMPTY) || (d >= FIRSTTAIL && d <= LASTTAIL) || d <= LASTOBJECT)
                    {   createcreature(FRAGMENT, i, x + xx, y + yy, xx, yy, 255);
        }   }   }   }
    break;
    case REMNANTS:
        effect(FXGET_OBJECT);
        worm[player].remnants = TRUE;
        icon(player, REMNANTS);
    break;
    case SIDESHOT:
        effect(FXGET_POWERUP);
        worm[player].sideshot = TRUE;
        icon(player, SIDESHOT);
    break;
    case MAGNET:
        effect(FXGET_OBJECT);
        i = 0;
        field[x][y] = EMPTY; // so that the magnet itself is destroyed
        for (xx = 0; xx <= FIELDX; xx++)
            for (yy = 0; yy <= FIELDY; yy++)
                if (field[xx][yy] <= LASTOBJECT)
                {   while (magnet[i].alive && i < MAGNETS)
                       i++;
                    if (i > MAGNETS)
                    {   break;
                    } else
                    {   magnet[i].x      = xx;
                        magnet[i].y      = yy;
                        magnet[i].object = field[xx][yy];
                        magnet[i].player = player;
                        magnet[i].alive  = TRUE;
                        i++;
                }   }
    break;
    case CUTTER:
        effect(FXGET_OBJECT);
        worm[player].cutter += ADD_CUTTER + arand(RAND_CUTTER);
        icon(player, CUTTER);
    break;
    case CYCLONE:
        /* create whirlwind */
        do
        {   x = arand(FIELDX - 10) + 5;
            y = arand(FIELDY - 5) + 5;
            d = field[x][y];
        } while (d < FIRSTEMPTY || d > LASTEMPTY);
        for (i = 0; i <= CREATURES; i++)
        {   if (!creature[i].alive)
            {   createcreature(WHIRLWIND, i, x, y, 0, 0, 255);
                break;
        }   }
    break;
    case LIGHTNING:
        effect(FXGET_OBJECT);
        for (xx = 0; xx <= FIELDX; xx++)
            for (yy = 0; yy <= FIELDY; yy++)
                otherfield[xx][yy] = EMPTY;
        for (xx = 0; xx <= FIELDX; xx++)
            for (yy = 0; yy <= FIELDY; yy++)
                if (field[xx][yy] == FIRSTTAIL + player)
                    for (xxx = xx - 1; xxx <= xx + 1; xxx++)
                        for (yyy = yy - 1; yyy <= yy + 1; yyy++)
                            if (valid(xxx, yyy))
                            {   d = field[xxx][yyy];
                                if (d == ORB
                                 || d == GOAT
                                 || d == MISSILE
                                 || d == PENGUIN
                                 || d == FISH
                                 || d == FRAGMENT
                                 || (d >= FIRSTTAIL && d <= LASTTAIL && d != FIRSTTAIL + player)
                                 || (d >= FIRSTHEAD && d <= LASTHEAD)
                                 || (d >= FIRSTDRIP && d <= LASTDRIP)
                                 || d <= LASTOBJECT)
                                {   otherfield[xxx][yyy] = TEMPLIGHTNING;
                                    draw(xxx, yyy, LIGHTNING);
                            }   }
        for (xx = 0; xx <= FIELDX; xx++)
        {   for (yy = 0; yy <= FIELDY; yy++)
            {   if (otherfield[xx][yy] == TEMPLIGHTNING)
                {   d = field[xx][yy];
                    if (d >= FIRSTMISSILE && d <= LASTMISSILE)
                    {   i = whichcreature(xx, yy, MISSILE, 255);
                        if (player != creature[i].type)
                        {   wormkillcreature(player, i);
                            change(xx, yy, EMPTY);
                        } else drawmissile(xx, yy, i);
                    } elif (d >= FIRSTDRIP && d <= LASTDRIP)
                    {   i = whichcreature(xx, yy, DRIP, 255);
                        if (player != creature[i].type)
                        {   wormkillcreature(player, i);
                            change(xx, yy, EMPTY);
                        } else draw(xx, yy, FIRSTDRIP + player);
                    } else
                    {   switch(d)
                        {
                        case CLOUD:
                        case DOG:
                        case FRAGMENT:
                        case GIRAFFE:
                        case GOAT:
                        case LION:
                        case OCTOPUS:
                        case ORB:
                        case PENGUIN:
                        case WHIRLWIND:
                            wormkillcreature(player, whichcreature(xx, yy, d, 255));
                            change(xx, yy, EMPTY);
                        break;
                        default:
                            /* eg. tail */
                            change(xx, yy, EMPTY);
                        break;
        }   }   }   }   }
    break;
    case PUSHER:
        effect(FXGET_OBJECT);
        worm[player].pusher = TRUE;
        icon(player, PUSHER);
    break;
    case GLOW:
        effect(FXGET_OBJECT);
        worm[player].glow += ADD_GLOW + arand(RAND_GLOW);
        if (worm[player].glow > GLOWLIMIT)
            worm[player].glow = GLOWLIMIT;
                icon(player, GLOW);
    break;
    case ENCLOSER:
        effect(FXGET_OBJECT);
        worm[player].encloser = TRUE;
        icon(player, ENCLOSER);
    break;
    case CONVERTER:
        effect(FXGET_OBJECT);
        for (i = 0; i <= CREATURES; i++)
            if (creature[i].alive && creature[i].species == FRAGMENT)
            {   xx = creature[i].x;
                yy = creature[i].y;
                creature[i].alive = FALSE;
                change(xx, yy, EMPTY);
                createcreature(MISSILE, i, xx, yy, 0, 0, player);
            }
    break;
    default:
        // assert(0);
    break;
    }
    return(score);
}

void icon(SBYTE player, UBYTE image)
{   /* Updates one of the boolean icons. The routine checks
    the status directly. */

    SBYTE x = -4, y = (player * 10) + 7;

    switch(image)
    {
    case AFFIXER:
        if (worm[player].affixer)
            draw(x, y, AFFIXER);
        else draw(x, y, BLACKENED);
    break;
    case PUSHER:
        if (worm[player].pusher)
            draw(x + 1, y, PUSHER);
        else draw(x + 1, y, BLACKENED);
    break;
    case REMNANTS:
        if (worm[player].remnants)
            draw(x + 2, y, REMNANTS);
        else draw(x + 2, y, BLACKENED);
    break;
    case SIDESHOT:
        if (worm[player].sideshot)
            draw(x, y + 1, SIDESHOT);
        else draw(x, y + 1, BLACKENED);
    break;
    case CUTTER:
        if (worm[player].cutter)
        {   if (worm[player].cutter < 10)
            {   if ((r % 4) <= 1)
                {   draw(x + 1, y + 1, CUTTER);
                } else draw(x + 1, y + 1, BLACKENED);
            } else draw(x + 1, y + 1, CUTTER);
        } else draw(x + 1, y + 1, BLACKENED);
    break;
    case ENCLOSER:
        if (worm[player].encloser)
            draw(x + 2, y + 1, ENCLOSER);
        else draw(x + 2, y + 1, BLACKENED);
    break;
    default:
    break;
}   }

MODULE void wormcol(SBYTE player, SBYTE x, SBYTE y)
{   ABOOL flag;
    UBYTE c = field[x][y], d;
    SBYTE i, xx, yy;
    ULONG score = 0;

    if (c >= FIRSTHEAD && c <= LASTHEAD)
        wormworm(x, y, player, c - FIRSTHEAD);
    elif (c == TIMEBOMB)
    {   /* push timebomb */
        i = whichcreature(x, y, TIMEBOMB, 255);
        if (valid(x + worm[player].deltax, y + worm[player].deltay))
        {   d = field[x + worm[player].deltax][y + worm[player].deltay];
            if (d <= LASTEMPTY)
            {   creature[i].x += worm[player].deltax;
                creature[i].y += worm[player].deltay;
                field[creature[i].x][creature[i].y] = TIMEBOMB;
                draw(creature[i].x, creature[i].y, ZERO + creature[i].time);
            } else // oops, you've fucked up! :-( Timebomb explodes!
            {   if (worm[player].glow == 0)
                    draw(worm[player].x, worm[player].y, eachworm[player][0][worm[player].deltax + 1 + (worm[player].deltay + 1) * 3]);
                else draw(worm[player].x, worm[player].y, eachworm[player][1][worm[player].deltax + 1 + (worm[player].deltay + 1) * 3]);
                bombblast(HEAD, player, worm[player].x, worm[player].y);
                creature[i].alive = FALSE;
        }   }
        else
        {   score += creature[i].score;
    }   }
    elif (c == ARROWUP)
    {   if (worm[player].deltay == -1)
        {   worm[player].speed = speedup(worm[player].speed, worm[player].brakes);
        } elif (worm[player].deltay == 1)
        {   worm[player].speed = slowdown(worm[player].speed, worm[player].brakes);
        }
        worm[player].last = ARROWUP;
    } elif (c == ARROWDOWN)
    {   if (worm[player].deltay == 1)
        {   worm[player].speed = speedup(worm[player].speed, worm[player].brakes);
        } elif (worm[player].deltay == -1)
        {   worm[player].speed = slowdown(worm[player].speed, worm[player].brakes);
        }
        worm[player].last = ARROWDOWN;
    } elif (c == FROST)
    {   worm[player].frosted = TRUE;
    } elif (c >= FIRSTPROTECTOR && c <= LASTPROTECTOR)
    {   protworm(x, y, c - FIRSTPROTECTOR, player);
    } elif (c >= FIRSTMISSILE && c <= LASTMISSILE)
    {   i = whichcreature(x, y, MISSILE, 255);
        wormcreature(player, i);
    } elif (c >= FIRSTDRIP && c <= LASTDRIP)
    {   i = whichcreature(x, y, DRIP, 255);
        wormcreature(player, i);
    } elif
    (   c == STONE
     || c == METAL
     || c == WOOD
     || c == FISH
     || c == GOAT
     || c == OCTOPUS
     || (c >= FIRSTTAIL && c <= LASTTAIL)
    ) // if you've hit something that is pushable
    {   flag = TRUE; // flag is whether you deserve to die
        if (worm[player].pusher)
        {   xx = x + worm[player].deltax;
            yy = y + worm[player].deltay;
            if (valid(xx, yy))
            {   d = field[xx][yy];
                if (d <= LASTEMPTY)
                // if you're pushing the square into a square which
                // has an object or is empty/silver/gold
                {   flag = FALSE; // then you don't deserve to die
                    if
                    (   c == FISH
                     || c == GOAT
                     || c == OCTOPUS
                    )
                    {   i = whichcreature(x, y, c, 255);
                        creature[i].x = xx;
                        creature[i].y = yy;
                        creature[i].visible = FALSE;
                    }
                    field[xx][yy] = c;
                    draw(xx, yy, c);
            }   }
            else // if pushing off the field edges
            {   flag = FALSE; // then you don't deserve to die
                // kill the creature
                if
                (   c == FISH
                 || c == GOAT
                 || c == OCTOPUS
                )
                {   i = whichcreature(x, y, c, 255);
                    wormkillcreature(player, i);
        }   }   }
        if (flag) // if we deserve to die
        {   if (c >= FIRSTTAIL && c <= LASTTAIL) // if we're pushing/hitting tail
            {   if (worm[player].armour > 0)
                {   effect(FXUSE_ARMOUR);
                    if (players > 1)
                    {   if (player == c - FIRSTTAIL)
                        {   score += POINTS_TURNSILVER;
                            worm[player].last = SILVER;
                        } else
                        {   score += POINTS_TURNGOLD;
                            worm[player].last = GOLD;
                }   }   }
                elif (!enclosed)
                {   worm[player].cause = c;
                    worm[player].alive = FALSE;
                    worm[player].victor = c - FIRSTTAIL;
            }   }
            elif
            (   c == FISH
             || c == GOAT
             || c == OCTOPUS
            )
            {   i = whichcreature(x, y, c, 255);
                wormcreature(player, i);
            } else
            {   worm[player].cause = c;
                worm[player].alive = FALSE;
                worm[player].victor = -1;
                if (c != WOOD)
                {   ramming(player);
    }   }   }   }
    elif (c == SLIME)
    {   if (worm[player].armour == 0)
        {   worm[player].cause = c;
            worm[player].alive = FALSE;
            worm[player].victor = -1;
    }   }
    elif
    (   c == BIRD
     || c == CLOUD
     || c == DOG
     || c == FRAGMENT
     || c == GIRAFFE
     || c == LION
     || c == ORB
     || c == PENGUIN
     || c == WHIRLWIND
    )
    {   i = whichcreature(x, y, c, 255);
        wormcreature(player, i);
    } elif (c == TELEPORT)
    {   i = whichteleport(x, y);
        if (blocked(i, worm[player].deltax, worm[player].deltay))
        {   worm[player].cause = TELEPORT;
            worm[player].victor = -1;
            worm[player].alive = FALSE;
            ramming(player);
        } else
        {   effect(FXUSE_TELEPORT);
            worm[player].x = xwrap(teleport[level][partner(i)].x + worm[player].deltax);
            worm[player].y = ywrap(teleport[level][partner(i)].y + worm[player].deltay);
    }   }
    elif (c >= FIRSTGLOW && c <= LASTGLOW)
    {   if (player != c - FIRSTGLOW)
        {   if (worm[player].armour == 0)
            {   worm[player].cause = GLOW;
                worm[player].victor = c - FIRSTGLOW;
                worm[player].alive = FALSE;
            }
            ramming(player);
    }   }
    else bothcol(player, x, y);
    wormscore(player, score);
}

AGLOBAL void drawhead(SBYTE player, SBYTE x, SBYTE y)
{   if (worm[player].alive)
    {   if (worm[player].glow == 0)
        {   draw(worm[player].x, worm[player].y, eachworm[player][0][worm[player].deltax + 1 + (worm[player].deltay + 1) * 3]);
            worm[player].flashed = FALSE;
        } else
        {   if (worm[player].glow < 10)
            {   if (!worm[player].flashed)
                {   draw(worm[player].x, worm[player].y, eachworm[player][1][worm[player].deltax + 1 + (worm[player].deltay + 1) * 3]);
                } else draw(worm[player].x, worm[player].y, WHITENED);
                worm[player].flashed = !worm[player].flashed;
            } else draw(worm[player].x, worm[player].y, eachworm[player][1][worm[player].deltax + 1 + (worm[player].deltay + 1) * 3]);
    }   }
    else draw(worm[player].x, worm[player].y, FIRSTPAIN + player);
}

AGLOBAL void drawsquare(SBYTE x, SBYTE y)
{   UBYTE which;

    if (field[x][y] == DOG)
    {   which = whichcreature(x, y, DOG, 255);
        if (!creature[which].dormant)
        {   draw(x, y, DOGDORMANT);
        } elif (creature[which].dormant <= CHASING)
        {   draw(x, y, DOGAWAKENING);
        } else
        {   draw(x, y, DOG);
    }   }
    elif (field[x][y] >= FIRSTHEAD && field[x][y] <= LASTHEAD)
    {   drawhead(field[x][y] - FIRSTHEAD, x, y);
    } else
    {   draw(x, y, field[x][y]);
}   }

MODULE void updatearrow(SBYTE arrowy)
{   SBYTE i, var = -1;

    /* var of:
                  -2         : many there
                  -1         : nothing there
                 0-3         : just that worm,
       FIRSTLETTER-LASTLETTER: just that number */

    for (i = 0; i <= 3; i++)
    {   if
        (   worm[i].control != NONE
         && worm[i].y == arrowy
         && (   worm[i].lives
             || (   field[worm[i].x][worm[i].y] >= FIRSTGRAVE
                 && field[worm[i].x][worm[i].y] <= LASTGRAVE
        )   )   )
        {   if (var == -1)
                var = i;
            else var = -2;
    }   }
    if (numbery == arrowy)
        if (var == -1)
            var = FIRSTLETTER + number - 1;
        else var = -2;
    if (var == -2)
        draw(ARROWX, arrowy, ALL);
    elif (var == -1)
        draw(ARROWX, arrowy, BLACKARROW);
    elif (var >= FIRSTLETTER && var <= LASTLETTER)
        draw(ARROWX, arrowy, var);
    else
    {   // assert(var >= 0 && var <= 3);
        if (worm[var].lives)
            draw(ARROWX, arrowy, FIRSTARROW + var);
        else draw(ARROWX, arrowy, FIRSTGRAVE + var);
}   }

MODULE void __inline bangdynamite(SBYTE x, SBYTE y, SBYTE player)
{   SBYTE xx, yy;

    // Infects (turns to bang-dynamite) all surrounding dynamite.

    for (xx = x - 1; xx <= x + 1; xx++)
    {   for (yy = y - 1; yy <= y + 1; yy++)
        {   if (valid(xx, yy))
            {   if (field[xx][yy] == DYNAMITE)
                {   field[xx][yy] = TEMPBANGDYNAMITE;
                    worm[player].dynamitescore += POINTS_DYNAMITE;
                    infector[xx][yy] = player;
}   }   }   }   }

MODULE void octopusfire(UBYTE which)
{   UBYTE i;
    SBYTE x, y, deltax, deltay;

    for (i = 0; i <= CREATURES; i++)
    {   if (!creature[i].alive)
        {   switch(creature[which].dir)
            {
            case 0:
                deltax = 0;
                deltay = -1;
            break;
            case 1:
                deltax = 1;
                deltay = -1;
            break;
            case 2:
                deltax = 1;
                deltay = 0;
            break;
            case 3:
                deltax = 1;
                deltay = 1;
            break;
            case 4:
                deltax = 0;
                deltay = 1;
            break;
            case 5:
                deltax = -1;
                deltay = 1;
            break;
            case 6:
                deltax = -1;
                deltay = 0;
            break;
            case 7:
                deltax = -1;
                deltay = -1;
            break;
            default:
            break;
            }
            x = creature[which].x + deltax;
            y = creature[which].y + deltay;
            if (valid(x, y) && field[x][y] >= FIRSTEMPTY && field[x][y] <= LASTEMPTY)
            {   effect(FXGET_PULSE);
                createcreature(FRAGMENT, i, x, y, deltax, deltay, 255);
                goto out;
    }   }   }

out:
    if (++creature[which].dir == 8)
    {   creature[which].dir = -1;
}   }

MODULE void createcreature(UBYTE species,
                           UBYTE which,
                           SBYTE x,
                           SBYTE y,
                           SBYTE deltax,
                           SBYTE deltay,
                           UBYTE player)
{   switch(species)
    {
    case FRAGMENT:
        creature[which].speed    = SPEED_FRAGMENT;
        creature[which].score    = SCORE_FRAGMENT;
        creature[which].hardness = HARDNESS_FRAGMENT;
        creature[which].visible  = TRUE;
        creature[which].last     = EMPTY;
        creature[which].type     = 255;
        change(x, y, FRAGMENT);
    break;
    case OCTOPUS:
        creature[which].speed    = SPEED_OCTOPUS;
        creature[which].score    = SCORE_OCTOPUS;
        creature[which].hardness = HARDNESS_OCTOPUS;
        creature[which].visible  = TRUE;
        creature[which].last     = field[x][y];
        creature[which].dir      = -1;
        creature[which].type     = 255;
        change(x, y, OCTOPUS);
    break;
    case FISH:
        creature[which].speed    = SPEED_FISH;
        creature[which].score    = SCORE_FISH;
        creature[which].hardness = HARDNESS_FISH;
        creature[which].visible  = TRUE;
        creature[which].last     =
        creature[which].oldlast  = field[x][y];
        creature[which].type     = 255;
        change(x, y, FISH);
    break;
    case GOAT:
        effect(FXBORN_GOAT);
        creature[which].speed    = SPEED_GOAT;
        creature[which].score    = SCORE_GOAT;
        creature[which].hardness = HARDNESS_GOAT;
        creature[which].visible  = TRUE;
        creature[which].last     =
        creature[which].oldlast  = field[x][y];
        creature[which].type     = 255;
        change(x, y, GOAT);
    break;
    case DOG:
        creature[which].speed    = SPEED_DOG;
        creature[which].score    = SCORE_DOG;
        creature[which].hardness = HARDNESS_DOG;
        creature[which].visible  = TRUE;
        creature[which].last     = EMPTY;
        creature[which].pos      = -1;
        creature[which].dormant  = DORMANT; /* dormant */
        creature[which].type     = 255;
        field[x][y] = DOG;
        draw(x, y, DOGDORMANT);
    break;
    case ORB:
        effect(FXBORN_ORB);
        creature[which].speed    = SPEED_ORB;
        creature[which].score    = SCORE_ORB;
        creature[which].hardness = HARDNESS_ORB;
        creature[which].visible  = TRUE;
        creature[which].last     = EMPTY;
        creature[which].multi    = 1;
        creature[which].type     = 255;
        change(x, y, ORB);
    break;
    case CLOUD:
        creature[which].speed    = SPEED_CLOUD;
        creature[which].score    = SCORE_CLOUD;
        creature[which].hardness = HARDNESS_CLOUD;
        creature[which].visible  = TRUE;
        creature[which].last     = EMPTY;
        creature[which].type     = 255;
        change(x, y, CLOUD);
    break;
    case PENGUIN:
        effect(FXBORN_PENGUIN);
        creature[which].speed    = SPEED_PENGUIN;
        creature[which].score    = SCORE_PENGUIN;
        creature[which].hardness = HARDNESS_PENGUIN;
        creature[which].visible  = TRUE;
        creature[which].last     = EMPTY;
        creature[which].type     = 255;
        change(x, y, PENGUIN);
    break;
    case TIMEBOMB:
        creature[which].speed    = SPEED_TIMEBOMB;
        creature[which].score    = SCORE_TIMEBOMB;
        creature[which].hardness = HARDNESS_TIMEBOMB;
        creature[which].last     = EMPTY;
        creature[which].time     = 10;
        creature[which].visible  = TRUE;
        creature[which].type     = 255;
        field[x][y] = TIMEBOMB;
        draw(x, y, ZERO + 9);
    break;
    case DRIP:
        effect(FXBORN_DRIP);
        creature[which].speed    = SPEED_DRIP;
        creature[which].score    = SCORE_DRIP;
        creature[which].hardness = HARDNESS_DRIP;
        creature[which].last     = EMPTY;
        creature[which].type     = player;
        creature[which].visible  = TRUE;
        change(x, y, FIRSTDRIP + creature[which].type);
    break;
    case WHIRLWIND:
        effect(FXGET_CYCLONE);
        creature[which].speed    = SPEED_WHIRLWIND;
        creature[which].score    = SCORE_WHIRLWIND;
        creature[which].hardness = HARDNESS_WHIRLWIND;
        creature[which].last     = EMPTY;
        creature[which].visible  = TRUE;
        creature[which].type     = 255;
        change(x, y, WHIRLWIND);
    break;
    case MISSILE:
        effect(FXBORN_MISSILE);
        creature[which].score    = SCORE_MISSILE;
        creature[which].speed    = SPEED_MISSILE;
        creature[which].hardness = HARDNESS_MISSILE;
        creature[which].visible  = FALSE;
        creature[which].last     = EMPTY;
        creature[which].type     = player;
        creature[which].frame    = 0;
    break;
    case BIRD:
        creature[which].speed    = SPEED_BIRD;
        creature[which].score    = SCORE_BIRD;
        creature[which].hardness = HARDNESS_BIRD;
        creature[which].visible  = TRUE;
        creature[which].last     = EMPTY;
        creature[which].frame    = 0;
        creature[which].dir      = 1;
        creature[which].type     = 255;
        change(x, y, BIRD);
    break;
    case OTTER:
        creature[which].speed    = SPEED_OTTER;
        creature[which].score    = SCORE_OTTER;
        creature[which].hardness = HARDNESS_OTTER;
        creature[which].visible  = TRUE;
        creature[which].last     = STONE; // should really check whether it should be dynamite instead
        creature[which].type     = 255;
        if (x == 0)
        {   creature[which].going    = OTTER_DOWN;
            creature[which].journey  = OTTER_RIGHT;
        } else
        {   creature[which].going    = OTTER_UP;
            creature[which].journey  = OTTER_LEFT;
        }
        field[x][y] = OTTER;
        draw(x, y, OTTER);
    break;
    case GIRAFFE:
        creature[which].speed    = SPEED_GIRAFFE;
        creature[which].score    = SCORE_GIRAFFE;
        creature[which].hardness = HARDNESS_GIRAFFE;
        creature[which].visible  = TRUE;
        creature[which].type     = 255;
        change(x, y, GIRAFFE);
    break;
    case LION:
        creature[which].speed    = SPEED_LION;
        creature[which].score    = SCORE_LION;
        creature[which].hardness = HARDNESS_LION;
        creature[which].visible  = TRUE;
        creature[which].type     = 255;
        change(x, y, LION);
    break;
    default:
    break;
    }

    if (level > 5 && creature[which].speed >= 2)
        creature[which].speed--;
    if (level > 10 && creature[which].speed >= 2)
        creature[which].speed--;
    if (level > 20 && creature[which].speed >= 2)
        creature[which].speed--;

    creature[which].alive   = TRUE;
    creature[which].x       = x;
    creature[which].y       = y;
    creature[which].deltax  = deltax;
    creature[which].deltay  = deltay;
    creature[which].species = species;
}

MODULE ULONG arand(ULONG number)
{   // Returns a value between 0 and number, inclusive.

    return((ULONG) (rand() % (number + 1)));
}

MODULE void protcreature(UBYTE player, UBYTE which)
{   UBYTE i;

    /* Handles collisions between protectors and creatures. */

    switch(creature[which].species)
    {
    case BIRD:
    case CLOUD:
    case DOG:
    case DRIP:
    case ORB:
    case PENGUIN:
        effect(FXUSE_PROTECTOR);
        wormkillcreature(player, which);
    break;
    case FRAGMENT:
        effect(FXUSE_PROTECTOR);
        reflect(which);
    break;
    case MISSILE:
        if (player != creature[which].type)
        {   effect(FXUSE_PROTECTOR);
            wormkillcreature(player, which);
        } else creature[which].visible = FALSE;
    break;
    case WHIRLWIND:
        for (i = 0; i <= PROTECTORS; i++)
        {   if
            (   protector[player][i].alive
             && protector[player][i].x == creature[which].x
             && protector[player][i].y == creature[which].y
            )
            {   protector[player][i].alive = FALSE;
        }   }
    break;
    default:
    break;
}   }

MODULE void wormcreature(UBYTE player, UBYTE which)
{   SBYTE newx, newy;

    /* Handles collisions between worms and creatures. */

    switch(creature[which].species)
    {
    case CLOUD:
        wormkillcreature(player, which);
        if (worm[player].armour == 0)
        {   worm[player].alive = FALSE;
            worm[player].cause = CLOUD;
            worm[player].victor = -1;
        }
    break;
    case DOG:
        if (creature[which].dormant == DORMANT)
        {   effect(FXBORN_DOG);
            creature[which].dormant = AWAKENING;
            creature[which].type    = player;
            worm[player].last       = DOG;
        } else
        {   wormkillcreature(player, which);
            if (worm[player].armour == 0)
            {   worm[player].alive  = FALSE;
                worm[player].cause  = DOG;
                worm[player].victor = -1;
        }   }
    break;
    case DRIP:
        wormkillcreature(player, which);
        if (player != creature[which].type && worm[player].armour == 0)
        {   worm[player].alive  = FALSE;
            worm[player].cause  = FIRSTDRIP + creature[which].type;
            worm[player].victor = -1;
        }
    break;
    case LION:
    case FISH:
    case GOAT:
    case OCTOPUS:
        worm[player].alive  = FALSE;
        worm[player].cause  = creature[which].species;
        worm[player].victor = -1;
    break;
    case FRAGMENT:
        if (worm[player].armour > 0)
        {   effect(FXUSE_ARMOUR);
            reflect(which);
        } else
        {   wormkillcreature(player, which);
            worm[player].cause  = FRAGMENT;
            worm[player].victor = -1;
            worm[player].alive  = FALSE;
        }
    break;
    case GIRAFFE:
        newx = worm[player].x - (worm[player].deltax * DISTANCE_GIRAFFE);
        newy = worm[player].y - (worm[player].deltay * DISTANCE_GIRAFFE);

        if
        (   valid(newx, newy)
         && field[newx][newy] != METAL
         && field[newx][newy] != STONE
         && field[newx][newy] != WOOD
         && field[newx][newy] != TELEPORT
        )
        {   worm[player].deltax = -worm[player].deltax;
            worm[player].deltay = -worm[player].deltay;
            worm[player].x = newx;
            worm[player].y = newy;
        } else
        {   worm[player].alive  = FALSE;
            worm[player].cause  = GIRAFFE;
            worm[player].victor = -1;
        }
    break;
    case MISSILE:
        if (creature[which].type == player)
        {   creature[which].visible = FALSE;
        } else
        {   wormkillcreature(player, which);
            if (worm[player].armour == 0)
            {   worm[player].cause  = FIRSTMISSILE + creature[which].type;
                worm[player].victor = creature[which].type;
                worm[player].alive  = FALSE;
            } else effect(FXUSE_ARMOUR);
        }
    break;
    case BIRD:
    case PENGUIN:
    case ORB:
        wormkillcreature(player, which);
        if (worm[player].armour > 0)
        {   effect(FXUSE_ARMOUR);
        } else
        {   worm[player].cause = creature[which].species;
            worm[player].victor = -1;
            worm[player].alive = FALSE;
        }
    break;
    case WHIRLWIND:
        worm[player].cause  = WHIRLWIND;
        worm[player].victor = -1;
        worm[player].alive  = FALSE;
    break;
    default:
    break;
}   }

MODULE void creaturecreature(UBYTE which1, UBYTE which2)
{   if (creature[which1].hardness > creature[which2].hardness)
    {   creature[which2].alive = FALSE;
        if (creature[which1].species == MISSILE)
        {   wormkillcreature(creature[which1].type, which2);
    }   }
    elif (creature[which1].hardness < creature[which2].hardness)
    {   creature[which1].alive = FALSE;
        if (creature[which2].species == MISSILE)
        {   wormkillcreature(creature[which2].type, which1);
    }   }
    else
    {   creature[which1].alive =
        creature[which2].alive = FALSE;
        change(creature[which1].x, creature[which1].y, BONUS);
}   }

/* NAME     align -- right-justify a string within another string
SYNOPSIS    align(STRPTR, SBYTE, TEXT);
FUNCTION    Moves all text in a string to the right, padding with
            spaces. Does not itself add a null terminator.
INPUTS      string - pointer to the string of text
              size - size in characters of the containing string
            filler - what to pad the left of the string with
NOTE        Null terminators are written over by this function, but that
            does not matter, because calling functions use Text() with an
            explicit length. This function only works with monospaced
            fonts. */

AGLOBAL void align(STRPTR string, SBYTE size, TEXT filler)
{   SBYTE i, shift, length;

    length = strlen((const char*) string);
    shift = size - length;
    for (i = 1; i <= length; i++)
        *(string + size - i) = *(string + size - i - shift);
    for (i = 0; i <= shift - 1; i++)
        *(string + i) = filler;
}

MODULE void ReadGameports(void)
{   ReadStandardJoystick(0);
    ReadStandardJoystick(1);
    ReadAdapterJoystick(2);
    ReadAdapterJoystick(3);
    ReadGamepads();
}

MODULE void drawmissile(SBYTE x, SBYTE y, UBYTE which)
{   draw(x, y, missileframes[creature[which].type][creature[which].frame]);
}

MODULE void checkrectangle(SBYTE direction, SBYTE player, SBYTE horizontalsize, SBYTE verticalsize)
{   AUTO SBYTE i, x, y, leftx, rightx, topy, bottomy;
    AUTO UBYTE c;
    PERSIST struct
    {   SBYTE deltax[4], deltay[4];
    } deltas[4] =
    { { { 0, -1,  0,  1}, // northwest
        {-1,  0,  1,  0}
      },
      { { 0,  1,  0, -1}, // northeast
        {-1,  0,  1,  0}
      },
      { { 0,  1,  0, -1}, // southeast
        { 1,  0, -1,  0}
      },
      { { 0, -1,  0,  1}, // southwest
        { 1,  0, -1,  0}
    } };
    PERSIST struct
    {   SBYTE leftx, rightx, topy, bottomy;
    } enclose[4] =
    { {-127,   -1, -127,  -1 }, // northwest
      {   1,  127, -127,  -1 }, // northeast
      {   1,  127,    1, 127 }, // southeast
      {-127,   -1,    1, 127 }  // southwest
    };

    x = worm[player].x;
    y = worm[player].y; // for speed

    for (i = 0; i <= verticalsize; i++)
    {   x += deltas[direction].deltax[0];
        y += deltas[direction].deltay[0];
        if ((!valid(x, y)) || field[x][y] != FIRSTTAIL + player)
        {   return;
    }   }
    for (i = 0; i <= horizontalsize; i++)
    {   x += deltas[direction].deltax[1];
        y += deltas[direction].deltay[1];
        if ((!valid(x, y)) || field[x][y] != FIRSTTAIL + player)
        {   return;
    }   }
    for (i = 0; i <= verticalsize; i++)
    {   x += deltas[direction].deltax[2];
        y += deltas[direction].deltay[2];
        if ((!valid(x, y)) || field[x][y] != FIRSTTAIL + player)
        {   return;
    }   }
    for (i = 0; i <= horizontalsize - 1; i++)
    {   x += deltas[direction].deltax[3];
        y += deltas[direction].deltay[3];
        if ((!valid(x, y)) || field[x][y] != FIRSTTAIL + player)
        {   return;
    }   }

    effect(FXDO_ENCLOSE);
    enclosed = TRUE;
    if (enclose[direction].leftx < -1)
        enclose[direction].leftx = -horizontalsize;
    elif (enclose[direction].leftx > 1)
        enclose[direction].leftx = horizontalsize + 1;
    if (enclose[direction].rightx < -1)
        enclose[direction].rightx = -(horizontalsize + 1);
    elif (enclose[direction].rightx > 1)
        enclose[direction].rightx = horizontalsize;
    if (enclose[direction].topy < -1)
        enclose[direction].topy = -verticalsize;
    elif (enclose[direction].topy > 1)
        enclose[direction].topy = verticalsize + 1;
    if (enclose[direction].bottomy < -1)
        enclose[direction].bottomy = -(verticalsize + 1);
    elif (enclose[direction].bottomy > 1)
        enclose[direction].bottomy = verticalsize;

      leftx = worm[player].x + enclose[direction].leftx;
     rightx = worm[player].x + enclose[direction].rightx;
       topy = worm[player].y + enclose[direction].topy;
    bottomy = worm[player].y + enclose[direction].bottomy;
    // assert(leftx >= 0 && rightx <= FIELDX && topy >= 0 && bottomy <= FIELDY && leftx < rightx && topy < bottomy);

    for (x = leftx; x <= rightx; x++)
    {   for (y = topy; y <= bottomy; y++)
        {   c = field[x][y];
            if
            (    (c >= FIRSTEMPTY && c <= LASTEMPTY)
             || ((c >= FIRSTTAIL  && c <= LASTTAIL ) && c != FIRSTTAIL + player)
             || ((c >= FIRSTGLOW  && c <= LASTGLOW ) && c != FIRSTGLOW + player)
            )
            {   change(x, y, FIRSTGLOW + player);
                wormscore(player, POINTS_ENCLOSURE + POINTS_TURNGOLD);
}   }   }   }

MODULE void endoflevel(void)
{   SBYTE advancer,
          player;
    UWORD counter[4] = {0, 0, 0, 0};
    SBYTE x, y;

        for (player = 0; player <= 3; player++)
        {   if (worm[player].lives)
            {   for (x = 0; x <= FIELDX; x++)
                {   for (y = 0; y <= FIELDY; y++)
                    {   if (field[x][y] == FIRSTTAIL + player || field[x][y] == FIRSTGLOW + player)
                        {   counter[player]++;
        }   }   }   }   }
        if (counter[0] >= counter[1]
         && counter[0] >= counter[2]
         && counter[0] >= counter[3])
        {   advancer = 0;
        } elif (counter[1] >= counter[0]
         && counter[1] >= counter[2]
         && counter[1] >= counter[3])
        {   advancer = 1;
        } elif (counter[2] >= counter[0]
         && counter[2] >= counter[1]
         && counter[2] >= counter[3])
        {   advancer = 2;
        } else
        {   advancer = 3;
        }

    if (level++ == 0)
    {   level = reallevel + 1;
        reallevel = 0;
    }
    stopfx();
    if (level > levels)
    {   effect(FXCELEBRATE);
    }
    newlevel(advancer);
}

MODULE FLAG getnumber(SBYTE player)
{   /* This function returns TRUE if the final number (ie. 9) was gotten,
    otherwise FALSE.

    The calling function is responsible for calling putnumber() if it
    wants a new number to appear. */

    wormscore(player, POINTS_LETTER * number);
    worm[player].numbers++;
    number++;

    if (number == 10)
    {   endoflevel();
        return(TRUE);
    }
    return(FALSE);
}